298 lines
11 KiB
Go
298 lines
11 KiB
Go
// This file is part of MinIO Console Server
|
|
// Copyright (c) 2022 MinIO, Inc.
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package restapi
|
|
|
|
import (
|
|
"net/http"
|
|
"testing"
|
|
|
|
"github.com/minio/console/models"
|
|
"github.com/minio/console/restapi/operations"
|
|
kmsAPI "github.com/minio/console/restapi/operations/k_m_s"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/suite"
|
|
)
|
|
|
|
type KMSTestSuite struct {
|
|
suite.Suite
|
|
assert *assert.Assertions
|
|
}
|
|
|
|
func (suite *KMSTestSuite) SetupSuite() {
|
|
suite.assert = assert.New(suite.T())
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TearDownSuite() {
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestRegisterKMSHandlers() {
|
|
api := &operations.ConsoleAPI{}
|
|
suite.assertHandlersAreNil(api)
|
|
registerKMSHandlers(api)
|
|
suite.assertHandlersAreNotNil(api)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) assertHandlersAreNil(api *operations.ConsoleAPI) {
|
|
suite.assert.Nil(api.KmsKMSStatusHandler)
|
|
suite.assert.Nil(api.KmsKMSCreateKeyHandler)
|
|
suite.assert.Nil(api.KmsKMSImportKeyHandler)
|
|
suite.assert.Nil(api.KmsKMSListKeysHandler)
|
|
suite.assert.Nil(api.KmsKMSKeyStatusHandler)
|
|
suite.assert.Nil(api.KmsKMSDeleteKeyHandler)
|
|
suite.assert.Nil(api.KmsKMSSetPolicyHandler)
|
|
suite.assert.Nil(api.KmsKMSAssignPolicyHandler)
|
|
suite.assert.Nil(api.KmsKMSDescribePolicyHandler)
|
|
suite.assert.Nil(api.KmsKMSGetPolicyHandler)
|
|
suite.assert.Nil(api.KmsKMSListPoliciesHandler)
|
|
suite.assert.Nil(api.KmsKMSDeletePolicyHandler)
|
|
suite.assert.Nil(api.KmsKMSDescribeIdentityHandler)
|
|
suite.assert.Nil(api.KmsKMSDescribeSelfIdentityHandler)
|
|
suite.assert.Nil(api.KmsKMSListIdentitiesHandler)
|
|
suite.assert.Nil(api.KmsKMSDeleteIdentityHandler)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) assertHandlersAreNotNil(api *operations.ConsoleAPI) {
|
|
suite.assert.NotNil(api.KmsKMSStatusHandler)
|
|
suite.assert.NotNil(api.KmsKMSCreateKeyHandler)
|
|
suite.assert.NotNil(api.KmsKMSImportKeyHandler)
|
|
suite.assert.NotNil(api.KmsKMSListKeysHandler)
|
|
suite.assert.NotNil(api.KmsKMSKeyStatusHandler)
|
|
suite.assert.NotNil(api.KmsKMSDeleteKeyHandler)
|
|
suite.assert.NotNil(api.KmsKMSSetPolicyHandler)
|
|
suite.assert.NotNil(api.KmsKMSAssignPolicyHandler)
|
|
suite.assert.NotNil(api.KmsKMSDescribePolicyHandler)
|
|
suite.assert.NotNil(api.KmsKMSGetPolicyHandler)
|
|
suite.assert.NotNil(api.KmsKMSListPoliciesHandler)
|
|
suite.assert.NotNil(api.KmsKMSDeletePolicyHandler)
|
|
suite.assert.NotNil(api.KmsKMSDescribeIdentityHandler)
|
|
suite.assert.NotNil(api.KmsKMSDescribeSelfIdentityHandler)
|
|
suite.assert.NotNil(api.KmsKMSListIdentitiesHandler)
|
|
suite.assert.NotNil(api.KmsKMSDeleteIdentityHandler)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSStatusHandlerWithError() {
|
|
params, api := suite.initKMSStatusRequest()
|
|
response := api.KmsKMSStatusHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSStatusDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSStatusRequest() (params kmsAPI.KMSStatusParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSCreateKeyHandlerWithError() {
|
|
params, api := suite.initKMSCreateKeyRequest()
|
|
response := api.KmsKMSCreateKeyHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSCreateKeyDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSCreateKeyRequest() (params kmsAPI.KMSCreateKeyParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSImportKeyHandlerWithError() {
|
|
params, api := suite.initKMSImportKeyRequest()
|
|
response := api.KmsKMSImportKeyHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSImportKeyDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSImportKeyRequest() (params kmsAPI.KMSImportKeyParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSListKeysHandlerWithError() {
|
|
params, api := suite.initKMSListKeysRequest()
|
|
response := api.KmsKMSListKeysHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSListKeysDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSListKeysRequest() (params kmsAPI.KMSListKeysParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSKeyStatusHandlerWithError() {
|
|
params, api := suite.initKMSKeyStatusRequest()
|
|
response := api.KmsKMSKeyStatusHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSKeyStatusDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSKeyStatusRequest() (params kmsAPI.KMSKeyStatusParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSDeleteKeyHandlerWithError() {
|
|
params, api := suite.initKMSDeleteKeyRequest()
|
|
response := api.KmsKMSDeleteKeyHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSDeleteKeyDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSDeleteKeyRequest() (params kmsAPI.KMSDeleteKeyParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSSetPolicyHandlerWithError() {
|
|
params, api := suite.initKMSSetPolicyRequest()
|
|
response := api.KmsKMSSetPolicyHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSSetPolicyDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSSetPolicyRequest() (params kmsAPI.KMSSetPolicyParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSAssignPolicyHandlerWithError() {
|
|
params, api := suite.initKMSAssignPolicyRequest()
|
|
response := api.KmsKMSAssignPolicyHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSAssignPolicyDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSAssignPolicyRequest() (params kmsAPI.KMSAssignPolicyParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSDescribePolicyHandlerWithError() {
|
|
params, api := suite.initKMSDescribePolicyRequest()
|
|
response := api.KmsKMSDescribePolicyHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSDescribePolicyDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSDescribePolicyRequest() (params kmsAPI.KMSDescribePolicyParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSGetPolicyHandlerWithError() {
|
|
params, api := suite.initKMSGetPolicyRequest()
|
|
response := api.KmsKMSGetPolicyHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSGetPolicyDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSGetPolicyRequest() (params kmsAPI.KMSGetPolicyParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSListPoliciesHandlerWithError() {
|
|
params, api := suite.initKMSListPoliciesRequest()
|
|
response := api.KmsKMSListPoliciesHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSListPoliciesDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSListPoliciesRequest() (params kmsAPI.KMSListPoliciesParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSDeletePolicyHandlerWithError() {
|
|
params, api := suite.initKMSDeletePolicyRequest()
|
|
response := api.KmsKMSDeletePolicyHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSDeletePolicyDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSDeletePolicyRequest() (params kmsAPI.KMSDeletePolicyParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSDescribeIdentityHandlerWithError() {
|
|
params, api := suite.initKMSDescribeIdentityRequest()
|
|
response := api.KmsKMSDescribeIdentityHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSDescribeIdentityDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSDescribeIdentityRequest() (params kmsAPI.KMSDescribeIdentityParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSDescribeSelfIdentityHandlerWithError() {
|
|
params, api := suite.initKMSDescribeSelfIdentityRequest()
|
|
response := api.KmsKMSDescribeSelfIdentityHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSDescribeSelfIdentityDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSDescribeSelfIdentityRequest() (params kmsAPI.KMSDescribeSelfIdentityParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSListIdentitiesHandlerWithError() {
|
|
params, api := suite.initKMSListIdentitiesRequest()
|
|
response := api.KmsKMSListIdentitiesHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSListIdentitiesDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSListIdentitiesRequest() (params kmsAPI.KMSListIdentitiesParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func (suite *KMSTestSuite) TestKMSDeleteIdentityHandlerWithError() {
|
|
params, api := suite.initKMSDeleteIdentityRequest()
|
|
response := api.KmsKMSDeleteIdentityHandler.Handle(params, &models.Principal{})
|
|
_, ok := response.(*kmsAPI.KMSDeleteIdentityDefault)
|
|
suite.assert.True(ok)
|
|
}
|
|
|
|
func (suite *KMSTestSuite) initKMSDeleteIdentityRequest() (params kmsAPI.KMSDeleteIdentityParams, api operations.ConsoleAPI) {
|
|
registerKMSHandlers(&api)
|
|
params.HTTPRequest = &http.Request{}
|
|
return params, api
|
|
}
|
|
|
|
func TestKMS(t *testing.T) {
|
|
suite.Run(t, new(KMSTestSuite))
|
|
}
|