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 }