github.com/minio/console@v1.4.1/api/admin_kms_test.go (about)

     1  // This file is part of MinIO Console Server
     2  // Copyright (c) 2022 MinIO, Inc.
     3  //
     4  // This program is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Affero General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // This program is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    12  // GNU Affero General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Affero General Public License
    15  // along with this program.  If not, see <http://www.gnu.org/licenses/>.
    16  
    17  package api
    18  
    19  import (
    20  	"context"
    21  	"net/http"
    22  	"net/http/httptest"
    23  	"os"
    24  	"testing"
    25  
    26  	"github.com/minio/console/api/operations"
    27  	kmsAPI "github.com/minio/console/api/operations/k_m_s"
    28  	"github.com/minio/console/models"
    29  	"github.com/stretchr/testify/assert"
    30  	"github.com/stretchr/testify/suite"
    31  )
    32  
    33  type KMSTestSuite struct {
    34  	suite.Suite
    35  	assert        *assert.Assertions
    36  	currentServer string
    37  	isServerSet   bool
    38  	server        *httptest.Server
    39  	adminClient   AdminClientMock
    40  }
    41  
    42  func (suite *KMSTestSuite) SetupSuite() {
    43  	suite.assert = assert.New(suite.T())
    44  	suite.adminClient = AdminClientMock{}
    45  }
    46  
    47  func (suite *KMSTestSuite) SetupTest() {
    48  	suite.server = httptest.NewServer(http.HandlerFunc(suite.serverHandler))
    49  	suite.currentServer, suite.isServerSet = os.LookupEnv(ConsoleMinIOServer)
    50  	os.Setenv(ConsoleMinIOServer, suite.server.URL)
    51  }
    52  
    53  func (suite *KMSTestSuite) serverHandler(w http.ResponseWriter, _ *http.Request) {
    54  	w.WriteHeader(400)
    55  }
    56  
    57  func (suite *KMSTestSuite) TearDownSuite() {
    58  }
    59  
    60  func (suite *KMSTestSuite) TearDownTest() {
    61  	if suite.isServerSet {
    62  		os.Setenv(ConsoleMinIOServer, suite.currentServer)
    63  	} else {
    64  		os.Unsetenv(ConsoleMinIOServer)
    65  	}
    66  }
    67  
    68  func (suite *KMSTestSuite) TestRegisterKMSHandlers() {
    69  	api := &operations.ConsoleAPI{}
    70  	suite.assertHandlersAreNil(api)
    71  	registerKMSHandlers(api)
    72  	suite.assertHandlersAreNotNil(api)
    73  }
    74  
    75  func (suite *KMSTestSuite) assertHandlersAreNil(api *operations.ConsoleAPI) {
    76  	suite.assert.Nil(api.KmsKMSStatusHandler)
    77  	suite.assert.Nil(api.KmsKMSMetricsHandler)
    78  	suite.assert.Nil(api.KmsKMSAPIsHandler)
    79  	suite.assert.Nil(api.KmsKMSVersionHandler)
    80  	suite.assert.Nil(api.KmsKMSCreateKeyHandler)
    81  	suite.assert.Nil(api.KmsKMSImportKeyHandler)
    82  	suite.assert.Nil(api.KmsKMSListKeysHandler)
    83  	suite.assert.Nil(api.KmsKMSKeyStatusHandler)
    84  	suite.assert.Nil(api.KmsKMSDeleteKeyHandler)
    85  	suite.assert.Nil(api.KmsKMSSetPolicyHandler)
    86  	suite.assert.Nil(api.KmsKMSAssignPolicyHandler)
    87  	suite.assert.Nil(api.KmsKMSDescribePolicyHandler)
    88  	suite.assert.Nil(api.KmsKMSGetPolicyHandler)
    89  	suite.assert.Nil(api.KmsKMSListPoliciesHandler)
    90  	suite.assert.Nil(api.KmsKMSDeletePolicyHandler)
    91  	suite.assert.Nil(api.KmsKMSDescribeIdentityHandler)
    92  	suite.assert.Nil(api.KmsKMSDescribeSelfIdentityHandler)
    93  	suite.assert.Nil(api.KmsKMSListIdentitiesHandler)
    94  	suite.assert.Nil(api.KmsKMSDeleteIdentityHandler)
    95  }
    96  
    97  func (suite *KMSTestSuite) assertHandlersAreNotNil(api *operations.ConsoleAPI) {
    98  	suite.assert.NotNil(api.KmsKMSStatusHandler)
    99  	suite.assert.NotNil(api.KmsKMSMetricsHandler)
   100  	suite.assert.NotNil(api.KmsKMSAPIsHandler)
   101  	suite.assert.NotNil(api.KmsKMSVersionHandler)
   102  	suite.assert.NotNil(api.KmsKMSCreateKeyHandler)
   103  	suite.assert.NotNil(api.KmsKMSImportKeyHandler)
   104  	suite.assert.NotNil(api.KmsKMSListKeysHandler)
   105  	suite.assert.NotNil(api.KmsKMSKeyStatusHandler)
   106  	suite.assert.NotNil(api.KmsKMSDeleteKeyHandler)
   107  	suite.assert.NotNil(api.KmsKMSSetPolicyHandler)
   108  	suite.assert.NotNil(api.KmsKMSAssignPolicyHandler)
   109  	suite.assert.NotNil(api.KmsKMSDescribePolicyHandler)
   110  	suite.assert.NotNil(api.KmsKMSGetPolicyHandler)
   111  	suite.assert.NotNil(api.KmsKMSListPoliciesHandler)
   112  	suite.assert.NotNil(api.KmsKMSDeletePolicyHandler)
   113  	suite.assert.NotNil(api.KmsKMSDescribeIdentityHandler)
   114  	suite.assert.NotNil(api.KmsKMSDescribeSelfIdentityHandler)
   115  	suite.assert.NotNil(api.KmsKMSListIdentitiesHandler)
   116  	suite.assert.NotNil(api.KmsKMSDeleteIdentityHandler)
   117  }
   118  
   119  func (suite *KMSTestSuite) TestKMSStatusHandlerWithError() {
   120  	params, api := suite.initKMSStatusRequest()
   121  	response := api.KmsKMSStatusHandler.Handle(params, &models.Principal{})
   122  	_, ok := response.(*kmsAPI.KMSStatusDefault)
   123  	suite.assert.True(ok)
   124  }
   125  
   126  func (suite *KMSTestSuite) initKMSStatusRequest() (params kmsAPI.KMSStatusParams, api operations.ConsoleAPI) {
   127  	registerKMSHandlers(&api)
   128  	params.HTTPRequest = &http.Request{}
   129  	return params, api
   130  }
   131  
   132  func (suite *KMSTestSuite) TestKMSStatusWithoutError() {
   133  	ctx := context.Background()
   134  	res, err := kmsStatus(ctx, suite.adminClient)
   135  	suite.assert.NotNil(res)
   136  	suite.assert.Nil(err)
   137  }
   138  
   139  func (suite *KMSTestSuite) TestKMSMetricsHandlerWithError() {
   140  	params, api := suite.initKMSMetricsRequest()
   141  	response := api.KmsKMSMetricsHandler.Handle(params, &models.Principal{})
   142  	_, ok := response.(*kmsAPI.KMSMetricsDefault)
   143  	suite.assert.True(ok)
   144  }
   145  
   146  func (suite *KMSTestSuite) initKMSMetricsRequest() (params kmsAPI.KMSMetricsParams, api operations.ConsoleAPI) {
   147  	registerKMSHandlers(&api)
   148  	params.HTTPRequest = &http.Request{}
   149  	return params, api
   150  }
   151  
   152  func (suite *KMSTestSuite) TestKMSMetricsWithoutError() {
   153  	ctx := context.Background()
   154  	res, err := kmsMetrics(ctx, suite.adminClient)
   155  	suite.assert.NotNil(res)
   156  	suite.assert.Nil(err)
   157  }
   158  
   159  func (suite *KMSTestSuite) TestKMSAPIsHandlerWithError() {
   160  	params, api := suite.initKMSAPIsRequest()
   161  	response := api.KmsKMSAPIsHandler.Handle(params, &models.Principal{})
   162  	_, ok := response.(*kmsAPI.KMSAPIsDefault)
   163  	suite.assert.True(ok)
   164  }
   165  
   166  func (suite *KMSTestSuite) initKMSAPIsRequest() (params kmsAPI.KMSAPIsParams, api operations.ConsoleAPI) {
   167  	registerKMSHandlers(&api)
   168  	params.HTTPRequest = &http.Request{}
   169  	return params, api
   170  }
   171  
   172  func (suite *KMSTestSuite) TestKMSAPIsWithoutError() {
   173  	ctx := context.Background()
   174  	res, err := kmsAPIs(ctx, suite.adminClient)
   175  	suite.assert.NotNil(res)
   176  	suite.assert.Nil(err)
   177  }
   178  
   179  func (suite *KMSTestSuite) TestKMSVersionHandlerWithError() {
   180  	params, api := suite.initKMSVersionRequest()
   181  	response := api.KmsKMSVersionHandler.Handle(params, &models.Principal{})
   182  	_, ok := response.(*kmsAPI.KMSVersionDefault)
   183  	suite.assert.True(ok)
   184  }
   185  
   186  func (suite *KMSTestSuite) initKMSVersionRequest() (params kmsAPI.KMSVersionParams, api operations.ConsoleAPI) {
   187  	registerKMSHandlers(&api)
   188  	params.HTTPRequest = &http.Request{}
   189  	return params, api
   190  }
   191  
   192  func (suite *KMSTestSuite) TestKMSVersionWithoutError() {
   193  	ctx := context.Background()
   194  	res, err := kmsVersion(ctx, suite.adminClient)
   195  	suite.assert.NotNil(res)
   196  	suite.assert.Nil(err)
   197  }
   198  
   199  func (suite *KMSTestSuite) TestKMSCreateKeyHandlerWithError() {
   200  	params, api := suite.initKMSCreateKeyRequest()
   201  	response := api.KmsKMSCreateKeyHandler.Handle(params, &models.Principal{})
   202  	_, ok := response.(*kmsAPI.KMSCreateKeyDefault)
   203  	suite.assert.True(ok)
   204  }
   205  
   206  func (suite *KMSTestSuite) initKMSCreateKeyRequest() (params kmsAPI.KMSCreateKeyParams, api operations.ConsoleAPI) {
   207  	registerKMSHandlers(&api)
   208  	params.HTTPRequest = &http.Request{}
   209  	key := "key"
   210  	params.Body = &models.KmsCreateKeyRequest{Key: &key}
   211  	return params, api
   212  }
   213  
   214  func (suite *KMSTestSuite) TestKMSCreateKeyWithoutError() {
   215  	ctx := context.Background()
   216  	err := createKey(ctx, "key", suite.adminClient)
   217  	suite.assert.Nil(err)
   218  }
   219  
   220  func (suite *KMSTestSuite) TestKMSImportKeyHandlerWithError() {
   221  	params, api := suite.initKMSImportKeyRequest()
   222  	response := api.KmsKMSImportKeyHandler.Handle(params, &models.Principal{})
   223  	_, ok := response.(*kmsAPI.KMSImportKeyDefault)
   224  	suite.assert.True(ok)
   225  }
   226  
   227  func (suite *KMSTestSuite) initKMSImportKeyRequest() (params kmsAPI.KMSImportKeyParams, api operations.ConsoleAPI) {
   228  	registerKMSHandlers(&api)
   229  	params.HTTPRequest = &http.Request{}
   230  	return params, api
   231  }
   232  
   233  func (suite *KMSTestSuite) TestKMSImportKeyWithoutError() {
   234  	ctx := context.Background()
   235  	err := importKey(ctx, "key", []byte(""), suite.adminClient)
   236  	suite.assert.Nil(err)
   237  }
   238  
   239  func (suite *KMSTestSuite) TestKMSListKeysHandlerWithError() {
   240  	params, api := suite.initKMSListKeysRequest()
   241  	response := api.KmsKMSListKeysHandler.Handle(params, &models.Principal{})
   242  	_, ok := response.(*kmsAPI.KMSListKeysDefault)
   243  	suite.assert.True(ok)
   244  }
   245  
   246  func (suite *KMSTestSuite) initKMSListKeysRequest() (params kmsAPI.KMSListKeysParams, api operations.ConsoleAPI) {
   247  	registerKMSHandlers(&api)
   248  	params.HTTPRequest = &http.Request{}
   249  	return params, api
   250  }
   251  
   252  func (suite *KMSTestSuite) TestKMSListKeysWithoutError() {
   253  	ctx := context.Background()
   254  	res, err := listKeys(ctx, "", suite.adminClient)
   255  	suite.assert.NotNil(res)
   256  	suite.assert.Nil(err)
   257  }
   258  
   259  func (suite *KMSTestSuite) TestKMSKeyStatusHandlerWithError() {
   260  	params, api := suite.initKMSKeyStatusRequest()
   261  	response := api.KmsKMSKeyStatusHandler.Handle(params, &models.Principal{})
   262  	_, ok := response.(*kmsAPI.KMSKeyStatusDefault)
   263  	suite.assert.True(ok)
   264  }
   265  
   266  func (suite *KMSTestSuite) initKMSKeyStatusRequest() (params kmsAPI.KMSKeyStatusParams, api operations.ConsoleAPI) {
   267  	registerKMSHandlers(&api)
   268  	params.HTTPRequest = &http.Request{}
   269  	return params, api
   270  }
   271  
   272  func (suite *KMSTestSuite) TestKMSKeyStatusWithoutError() {
   273  	ctx := context.Background()
   274  	res, err := keyStatus(ctx, "key", suite.adminClient)
   275  	suite.assert.NotNil(res)
   276  	suite.assert.Nil(err)
   277  }
   278  
   279  func (suite *KMSTestSuite) TestKMSDeleteKeyHandlerWithError() {
   280  	params, api := suite.initKMSDeleteKeyRequest()
   281  	response := api.KmsKMSDeleteKeyHandler.Handle(params, &models.Principal{})
   282  	_, ok := response.(*kmsAPI.KMSDeleteKeyDefault)
   283  	suite.assert.True(ok)
   284  }
   285  
   286  func (suite *KMSTestSuite) initKMSDeleteKeyRequest() (params kmsAPI.KMSDeleteKeyParams, api operations.ConsoleAPI) {
   287  	registerKMSHandlers(&api)
   288  	params.HTTPRequest = &http.Request{}
   289  	return params, api
   290  }
   291  
   292  func (suite *KMSTestSuite) TestKMSDeleteKeyWithoutError() {
   293  	ctx := context.Background()
   294  	err := deleteKey(ctx, "key", suite.adminClient)
   295  	suite.assert.Nil(err)
   296  }
   297  
   298  func (suite *KMSTestSuite) TestKMSSetPolicyHandlerWithError() {
   299  	params, api := suite.initKMSSetPolicyRequest()
   300  	response := api.KmsKMSSetPolicyHandler.Handle(params, &models.Principal{})
   301  	_, ok := response.(*kmsAPI.KMSSetPolicyDefault)
   302  	suite.assert.True(ok)
   303  }
   304  
   305  func (suite *KMSTestSuite) initKMSSetPolicyRequest() (params kmsAPI.KMSSetPolicyParams, api operations.ConsoleAPI) {
   306  	registerKMSHandlers(&api)
   307  	params.HTTPRequest = &http.Request{}
   308  	policy := "policy"
   309  	params.Body = &models.KmsSetPolicyRequest{Policy: &policy}
   310  	return params, api
   311  }
   312  
   313  func (suite *KMSTestSuite) TestKMSSetPolicyWithoutError() {
   314  	ctx := context.Background()
   315  	err := setPolicy(ctx, "policy", []byte(""), suite.adminClient)
   316  	suite.assert.Nil(err)
   317  }
   318  
   319  func (suite *KMSTestSuite) TestKMSAssignPolicyHandlerWithError() {
   320  	params, api := suite.initKMSAssignPolicyRequest()
   321  	response := api.KmsKMSAssignPolicyHandler.Handle(params, &models.Principal{})
   322  	_, ok := response.(*kmsAPI.KMSAssignPolicyDefault)
   323  	suite.assert.True(ok)
   324  }
   325  
   326  func (suite *KMSTestSuite) initKMSAssignPolicyRequest() (params kmsAPI.KMSAssignPolicyParams, api operations.ConsoleAPI) {
   327  	registerKMSHandlers(&api)
   328  	params.HTTPRequest = &http.Request{}
   329  	return params, api
   330  }
   331  
   332  func (suite *KMSTestSuite) TestKMSAssignPolicyWithoutError() {
   333  	ctx := context.Background()
   334  	err := assignPolicy(ctx, "policy", []byte(""), suite.adminClient)
   335  	suite.assert.Nil(err)
   336  }
   337  
   338  func (suite *KMSTestSuite) TestKMSDescribePolicyHandlerWithError() {
   339  	params, api := suite.initKMSDescribePolicyRequest()
   340  	response := api.KmsKMSDescribePolicyHandler.Handle(params, &models.Principal{})
   341  	_, ok := response.(*kmsAPI.KMSDescribePolicyDefault)
   342  	suite.assert.True(ok)
   343  }
   344  
   345  func (suite *KMSTestSuite) initKMSDescribePolicyRequest() (params kmsAPI.KMSDescribePolicyParams, api operations.ConsoleAPI) {
   346  	registerKMSHandlers(&api)
   347  	params.HTTPRequest = &http.Request{}
   348  	return params, api
   349  }
   350  
   351  func (suite *KMSTestSuite) TestKMSDescribePolicyWithoutError() {
   352  	ctx := context.Background()
   353  	res, err := describePolicy(ctx, "policy", suite.adminClient)
   354  	suite.assert.NotNil(res)
   355  	suite.assert.Nil(err)
   356  }
   357  
   358  func (suite *KMSTestSuite) TestKMSGetPolicyHandlerWithError() {
   359  	params, api := suite.initKMSGetPolicyRequest()
   360  	response := api.KmsKMSGetPolicyHandler.Handle(params, &models.Principal{})
   361  	_, ok := response.(*kmsAPI.KMSGetPolicyDefault)
   362  	suite.assert.True(ok)
   363  }
   364  
   365  func (suite *KMSTestSuite) initKMSGetPolicyRequest() (params kmsAPI.KMSGetPolicyParams, api operations.ConsoleAPI) {
   366  	registerKMSHandlers(&api)
   367  	params.HTTPRequest = &http.Request{}
   368  	return params, api
   369  }
   370  
   371  func (suite *KMSTestSuite) TestKMSGetPolicyWithoutError() {
   372  	ctx := context.Background()
   373  	res, err := getPolicy(ctx, "policy", suite.adminClient)
   374  	suite.assert.NotNil(res)
   375  	suite.assert.Nil(err)
   376  }
   377  
   378  func (suite *KMSTestSuite) TestKMSListPoliciesHandlerWithError() {
   379  	params, api := suite.initKMSListPoliciesRequest()
   380  	response := api.KmsKMSListPoliciesHandler.Handle(params, &models.Principal{})
   381  	_, ok := response.(*kmsAPI.KMSListPoliciesDefault)
   382  	suite.assert.True(ok)
   383  }
   384  
   385  func (suite *KMSTestSuite) initKMSListPoliciesRequest() (params kmsAPI.KMSListPoliciesParams, api operations.ConsoleAPI) {
   386  	registerKMSHandlers(&api)
   387  	params.HTTPRequest = &http.Request{}
   388  	return params, api
   389  }
   390  
   391  func (suite *KMSTestSuite) TestKMSListPoliciesWithoutError() {
   392  	ctx := context.Background()
   393  	res, err := listKMSPolicies(ctx, "", suite.adminClient)
   394  	suite.assert.NotNil(res)
   395  	suite.assert.Nil(err)
   396  }
   397  
   398  func (suite *KMSTestSuite) TestKMSDeletePolicyHandlerWithError() {
   399  	params, api := suite.initKMSDeletePolicyRequest()
   400  	response := api.KmsKMSDeletePolicyHandler.Handle(params, &models.Principal{})
   401  	_, ok := response.(*kmsAPI.KMSDeletePolicyDefault)
   402  	suite.assert.True(ok)
   403  }
   404  
   405  func (suite *KMSTestSuite) initKMSDeletePolicyRequest() (params kmsAPI.KMSDeletePolicyParams, api operations.ConsoleAPI) {
   406  	registerKMSHandlers(&api)
   407  	params.HTTPRequest = &http.Request{}
   408  	return params, api
   409  }
   410  
   411  func (suite *KMSTestSuite) TestKMSDeletePolicyWithoutError() {
   412  	ctx := context.Background()
   413  	err := deletePolicy(ctx, "policy", suite.adminClient)
   414  	suite.assert.Nil(err)
   415  }
   416  
   417  func (suite *KMSTestSuite) TestKMSDescribeIdentityHandlerWithError() {
   418  	params, api := suite.initKMSDescribeIdentityRequest()
   419  	response := api.KmsKMSDescribeIdentityHandler.Handle(params, &models.Principal{})
   420  	_, ok := response.(*kmsAPI.KMSDescribeIdentityDefault)
   421  	suite.assert.True(ok)
   422  }
   423  
   424  func (suite *KMSTestSuite) initKMSDescribeIdentityRequest() (params kmsAPI.KMSDescribeIdentityParams, api operations.ConsoleAPI) {
   425  	registerKMSHandlers(&api)
   426  	params.HTTPRequest = &http.Request{}
   427  	return params, api
   428  }
   429  
   430  func (suite *KMSTestSuite) TestKMSDescribeIdentityWithoutError() {
   431  	ctx := context.Background()
   432  	res, err := describeIdentity(ctx, "identity", suite.adminClient)
   433  	suite.assert.NotNil(res)
   434  	suite.assert.Nil(err)
   435  }
   436  
   437  func (suite *KMSTestSuite) TestKMSDescribeSelfIdentityHandlerWithError() {
   438  	params, api := suite.initKMSDescribeSelfIdentityRequest()
   439  	response := api.KmsKMSDescribeSelfIdentityHandler.Handle(params, &models.Principal{})
   440  	_, ok := response.(*kmsAPI.KMSDescribeSelfIdentityDefault)
   441  	suite.assert.True(ok)
   442  }
   443  
   444  func (suite *KMSTestSuite) initKMSDescribeSelfIdentityRequest() (params kmsAPI.KMSDescribeSelfIdentityParams, api operations.ConsoleAPI) {
   445  	registerKMSHandlers(&api)
   446  	params.HTTPRequest = &http.Request{}
   447  	return params, api
   448  }
   449  
   450  func (suite *KMSTestSuite) TestKMSDescribeSelfIdentityWithoutError() {
   451  	ctx := context.Background()
   452  	res, err := describeSelfIdentity(ctx, suite.adminClient)
   453  	suite.assert.NotNil(res)
   454  	suite.assert.Nil(err)
   455  }
   456  
   457  func (suite *KMSTestSuite) TestKMSListIdentitiesHandlerWithError() {
   458  	params, api := suite.initKMSListIdentitiesRequest()
   459  	response := api.KmsKMSListIdentitiesHandler.Handle(params, &models.Principal{})
   460  	_, ok := response.(*kmsAPI.KMSListIdentitiesDefault)
   461  	suite.assert.True(ok)
   462  }
   463  
   464  func (suite *KMSTestSuite) initKMSListIdentitiesRequest() (params kmsAPI.KMSListIdentitiesParams, api operations.ConsoleAPI) {
   465  	registerKMSHandlers(&api)
   466  	params.HTTPRequest = &http.Request{}
   467  	return params, api
   468  }
   469  
   470  func (suite *KMSTestSuite) TestKMSListIdentitiesWithoutError() {
   471  	ctx := context.Background()
   472  	res, err := listIdentities(ctx, "", suite.adminClient)
   473  	suite.assert.NotNil(res)
   474  	suite.assert.Nil(err)
   475  }
   476  
   477  func (suite *KMSTestSuite) TestKMSDeleteIdentityHandlerWithError() {
   478  	params, api := suite.initKMSDeleteIdentityRequest()
   479  	response := api.KmsKMSDeleteIdentityHandler.Handle(params, &models.Principal{})
   480  	_, ok := response.(*kmsAPI.KMSDeleteIdentityDefault)
   481  	suite.assert.True(ok)
   482  }
   483  
   484  func (suite *KMSTestSuite) initKMSDeleteIdentityRequest() (params kmsAPI.KMSDeleteIdentityParams, api operations.ConsoleAPI) {
   485  	registerKMSHandlers(&api)
   486  	params.HTTPRequest = &http.Request{}
   487  	return params, api
   488  }
   489  
   490  func (suite *KMSTestSuite) TestKMSDeleteIdentityWithoutError() {
   491  	ctx := context.Background()
   492  	err := deleteIdentity(ctx, "identity", suite.adminClient)
   493  	suite.assert.Nil(err)
   494  }
   495  
   496  func TestKMS(t *testing.T) {
   497  	suite.Run(t, new(KMSTestSuite))
   498  }