aliyun /
credentials-go
| Conditions | 3 |
| Total Lines | 274 |
| Code Lines | 208 |
| Lines | 0 |
| Ratio | 0 % |
| Changes | 0 | ||
Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.
For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.
Commonly applied refactorings include:
If many parameters/temporary variables are present:
| 1 | package credentials |
||
| 233 | func TestProfileProvider(t *testing.T) { |
||
| 234 | var HOME string |
||
| 235 | if runtime.GOOS == "windows" { |
||
| 236 | HOME = "USERPROFILE" |
||
| 237 | } else { |
||
| 238 | HOME = "HOME" |
||
| 239 | } |
||
| 240 | path, ok := os.LookupEnv(HOME) |
||
| 241 | assert.True(t, ok) |
||
| 242 | os.Unsetenv(HOME) |
||
| 243 | |||
| 244 | // testcase 1, no HOME or USERPROFILE environment variable set |
||
| 245 | p := newProfileProvider() |
||
| 246 | c, err := p.resolve() |
||
| 247 | assert.Nil(t, c) |
||
| 248 | assert.EqualError(t, err, "The default credential file path is invalid") |
||
| 249 | |||
| 250 | originFilePath := os.Getenv(ENVCredentialFile) |
||
| 251 | os.Setenv(ENVCredentialFile, "") |
||
| 252 | defer func() { |
||
| 253 | os.Setenv(ENVCredentialFile, originFilePath) |
||
| 254 | }() |
||
| 255 | c, err = p.resolve() |
||
| 256 | assert.Nil(t, c) |
||
| 257 | assert.EqualError(t, err, "ALIBABA_CLOUD_CREDENTIALS_FILE cannot be empty") |
||
| 258 | |||
| 259 | // testcase 2, default profile object |
||
| 260 | os.Unsetenv(ENVCredentialFile) |
||
| 261 | os.Setenv(HOME, path) |
||
| 262 | p = newProfileProvider() |
||
| 263 | value, ok := p.(*profileProvider) |
||
| 264 | assert.True(t, ok) |
||
| 265 | assert.Equal(t, value.Profile, "default") |
||
| 266 | |||
| 267 | // testcase 3, credential file does not exist in the default path |
||
| 268 | // and section name does not exist |
||
| 269 | p = newProfileProvider("first") |
||
| 270 | value, ok = p.(*profileProvider) |
||
| 271 | assert.True(t, ok) |
||
| 272 | assert.Equal(t, value.Profile, "first") |
||
| 273 | c, err = p.resolve() |
||
| 274 | assert.Nil(t, c) |
||
| 275 | assert.Nil(t, err) |
||
| 276 | |||
| 277 | // testcase 4, credential file path is error |
||
| 278 | os.Setenv(ENVCredentialFile, "../../credentials_error") |
||
| 279 | p = newProfileProvider() |
||
| 280 | c, err = p.resolve() |
||
| 281 | assert.Nil(t, c) |
||
| 282 | assert.True(t, strings.Contains(err.Error(), "ERROR: Can not open file")) |
||
| 283 | |||
| 284 | // create profile |
||
| 285 | os.Setenv(ENVCredentialFile, "./credentials") |
||
| 286 | |||
| 287 | file, err := os.Create("./credentials") |
||
| 288 | assert.Nil(t, err) |
||
| 289 | file.WriteString(inistr) |
||
| 290 | file.Close() |
||
| 291 | defer os.Remove("./credentials") |
||
| 292 | |||
| 293 | // testcase 5, section does not exist |
||
| 294 | p = newProfileProvider("NonExist") |
||
| 295 | c, err = p.resolve() |
||
| 296 | assert.Nil(t, c) |
||
| 297 | assert.Equal(t, "ERROR: Can not load section section 'NonExist' does not exist", err.Error()) |
||
| 298 | |||
| 299 | // testcase 6, credential type does not set |
||
| 300 | p = newProfileProvider("notype") |
||
| 301 | c, err = p.resolve() |
||
| 302 | assert.Nil(t, c) |
||
| 303 | assert.Equal(t, "Missing required type option error when getting key of section 'notype': key 'type' not exists", err.Error()) |
||
| 304 | |||
| 305 | // testcase 7, normal AK |
||
| 306 | p = newProfileProvider() |
||
| 307 | c, err = p.resolve() |
||
| 308 | assert.Nil(t, err) |
||
| 309 | // testcase 8, access_key_id key does not exist |
||
| 310 | p = newProfileProvider("noak") |
||
| 311 | c, err = p.resolve() |
||
| 312 | assert.Nil(t, c) |
||
| 313 | assert.Equal(t, "Missing required access_key_id option in profile for access_key", err.Error()) |
||
| 314 | // testcase 9, access_key_id value is empty |
||
| 315 | p = newProfileProvider("emptyak") |
||
| 316 | c, err = p.resolve() |
||
| 317 | assert.Nil(t, c) |
||
| 318 | assert.Equal(t, "access_key_id cannot be empty", err.Error()) |
||
| 319 | // testcase 10, access_key_secret key does not exist |
||
| 320 | p = newProfileProvider("noaksecret") |
||
| 321 | c, err = p.resolve() |
||
| 322 | assert.Nil(t, c) |
||
| 323 | assert.Equal(t, "Missing required access_key_secret option in profile for access_key", err.Error()) |
||
| 324 | // testcase 11, access_key_secret value is empty |
||
| 325 | p = newProfileProvider("emptyaksecret") |
||
| 326 | c, err = p.resolve() |
||
| 327 | assert.Nil(t, c) |
||
| 328 | assert.Equal(t, "access_key_secret cannot be empty", err.Error()) |
||
| 329 | |||
| 330 | //testcase 12, normal EcsRamRole |
||
| 331 | p = newProfileProvider("ecs") |
||
| 332 | c, err = p.resolve() |
||
| 333 | assert.Nil(t, err) |
||
| 334 | //testcase 13, key does not exist |
||
| 335 | p = newProfileProvider("noecs") |
||
| 336 | c, err = p.resolve() |
||
| 337 | assert.Nil(t, c) |
||
| 338 | assert.Equal(t, "Missing required role_name option in profile for ecs_ram_role", err.Error()) |
||
| 339 | //testcase 14, value is empty |
||
| 340 | p = newProfileProvider("emptyecs") |
||
| 341 | c, err = p.resolve() |
||
| 342 | assert.Nil(t, c) |
||
| 343 | assert.Equal(t, "role_name cannot be empty", err.Error()) |
||
| 344 | //testcase 15, timeout is not int |
||
| 345 | p = newProfileProvider("invalidRuntimeEcs") |
||
| 346 | c, err = p.resolve() |
||
| 347 | assert.Nil(t, c) |
||
| 348 | assert.Equal(t, "Please set timeout with an int value", err.Error()) |
||
| 349 | |||
| 350 | //testcase 16, normal RamRoleArn |
||
| 351 | p = newProfileProvider("ram") |
||
| 352 | c, err = p.resolve() |
||
| 353 | assert.Nil(t, err) |
||
| 354 | //testcase 17, access_key_id key does not exist |
||
| 355 | p = newProfileProvider("noramak") |
||
| 356 | c, err = p.resolve() |
||
| 357 | assert.Nil(t, c) |
||
| 358 | assert.Equal(t, "Missing required access_key_id option in profile for ram_role_arn", err.Error()) |
||
| 359 | //testcase 18, access_key_id value is empty |
||
| 360 | p = newProfileProvider("emptyramak") |
||
| 361 | c, err = p.resolve() |
||
| 362 | assert.Nil(t, c) |
||
| 363 | assert.Equal(t, "access_key_id cannot be empty", err.Error()) |
||
| 364 | //testcase 19, access_key_secret key does not exist |
||
| 365 | p = newProfileProvider("noramsecret") |
||
| 366 | c, err = p.resolve() |
||
| 367 | assert.Nil(t, c) |
||
| 368 | assert.Equal(t, "Missing required access_key_secret option in profile for ram_role_arn", err.Error()) |
||
| 369 | //testcase 20, access_key_secret value is empty |
||
| 370 | p = newProfileProvider("emptyramsecret") |
||
| 371 | c, err = p.resolve() |
||
| 372 | assert.Nil(t, c) |
||
| 373 | assert.Equal(t, "access_key_secret cannot be empty", err.Error()) |
||
| 374 | //testcase 21, role_arn key does not exist |
||
| 375 | p = newProfileProvider("noramarn") |
||
| 376 | c, err = p.resolve() |
||
| 377 | assert.Nil(t, c) |
||
| 378 | assert.Equal(t, "Missing required role_arn option in profile for ram_role_arn", err.Error()) |
||
| 379 | //testcase 22, role_arn value is empty |
||
| 380 | p = newProfileProvider("emptyramarn") |
||
| 381 | c, err = p.resolve() |
||
| 382 | assert.Nil(t, c) |
||
| 383 | assert.Equal(t, "role_arn cannot be empty", err.Error()) |
||
| 384 | //testcase 23, role_session_name key does not exist |
||
| 385 | p = newProfileProvider("noramsessionname") |
||
| 386 | c, err = p.resolve() |
||
| 387 | assert.Nil(t, c) |
||
| 388 | assert.Equal(t, "Missing required role_session_name option in profile for ram_role_arn", err.Error()) |
||
| 389 | //testcase 24, role_session_name value is empty |
||
| 390 | p = newProfileProvider("emptyramsessionname") |
||
| 391 | c, err = p.resolve() |
||
| 392 | assert.Nil(t, c) |
||
| 393 | assert.Equal(t, "role_session_name cannot be empty", err.Error()) |
||
| 394 | //testcase 25, role_session_expiration is not int |
||
| 395 | p = newProfileProvider("invalidexpirationram") |
||
| 396 | c, err = p.resolve() |
||
| 397 | assert.Nil(t, c) |
||
| 398 | assert.Equal(t, "role_session_expiration must be an int", err.Error()) |
||
| 399 | //testcase 26, timeout is not int |
||
| 400 | p = newProfileProvider("invalidRuntimeram") |
||
| 401 | c, err = p.resolve() |
||
| 402 | assert.Nil(t, c) |
||
| 403 | assert.Equal(t, "Please set timeout with an int value", err.Error()) |
||
| 404 | |||
| 405 | //testase 27, normal RsaKeyPair |
||
| 406 | file, err = os.Create("./pk.pem") |
||
| 407 | assert.Nil(t, err) |
||
| 408 | _, err = file.WriteString(privatekey) |
||
| 409 | assert.Nil(t, err) |
||
| 410 | file.Close() |
||
| 411 | |||
| 412 | p = newProfileProvider("rsa") |
||
| 413 | c, err = p.resolve() |
||
| 414 | assert.Nil(t, err) |
||
| 415 | defer os.Remove(`./pk.pem`) |
||
| 416 | //testcase 28, private_key_file key does not exist |
||
| 417 | p = newProfileProvider("norsaprivate") |
||
| 418 | c, err = p.resolve() |
||
| 419 | assert.Nil(t, c) |
||
| 420 | assert.Equal(t, "Missing required private_key_file option in profile for rsa_key_pair", err.Error()) |
||
| 421 | //testcase 29, private_key_file value is empty |
||
| 422 | p = newProfileProvider("emptyrsaprivate") |
||
| 423 | c, err = p.resolve() |
||
| 424 | assert.Nil(t, c) |
||
| 425 | assert.Equal(t, "private_key_file cannot be empty", err.Error()) |
||
| 426 | //testcase 30, public_key_id key does not exist |
||
| 427 | p = newProfileProvider("norsapublic") |
||
| 428 | c, err = p.resolve() |
||
| 429 | assert.Nil(t, c) |
||
| 430 | assert.Equal(t, "Missing required public_key_id option in profile for rsa_key_pair", err.Error()) |
||
| 431 | //testcase 31, public_key_id value is empty |
||
| 432 | p = newProfileProvider("emptyrsapublic") |
||
| 433 | c, err = p.resolve() |
||
| 434 | assert.Nil(t, c) |
||
| 435 | assert.Equal(t, "public_key_id cannot be empty", err.Error()) |
||
| 436 | //testcase 32, session_expiration is not int |
||
| 437 | p = newProfileProvider("invalidexpirationrsa") |
||
| 438 | c, err = p.resolve() |
||
| 439 | assert.Nil(t, c) |
||
| 440 | assert.Equal(t, "session_expiration must be an int", err.Error()) |
||
| 441 | //testcase 33, timeout is not int |
||
| 442 | p = newProfileProvider("invalidTimeoutrsa") |
||
| 443 | c, err = p.resolve() |
||
| 444 | assert.Nil(t, c) |
||
| 445 | assert.Equal(t, "Please set timeout with an int value", err.Error()) |
||
| 446 | //testcase 34, connect_timeout is not int |
||
| 447 | p = newProfileProvider("invalidConnectTimeoutrsa") |
||
| 448 | c, err = p.resolve() |
||
| 449 | assert.Nil(t, c) |
||
| 450 | assert.Equal(t, "Please set connect_timeout with an int value", err.Error()) |
||
| 451 | |||
| 452 | //testcase 35, normal RamRoleArn |
||
| 453 | p = newProfileProvider("sts") |
||
| 454 | c, err = p.resolve() |
||
| 455 | assert.Nil(t, err) |
||
| 456 | //testcase 36, access_key_id key does not exist |
||
| 457 | p = newProfileProvider("nostskey") |
||
| 458 | c, err = p.resolve() |
||
| 459 | assert.Nil(t, c) |
||
| 460 | assert.Equal(t, "Missing required access_key_id option in profile for sts", err.Error()) |
||
| 461 | //testcase 37, access_key_id value is empty |
||
| 462 | p = newProfileProvider("emptystskey") |
||
| 463 | c, err = p.resolve() |
||
| 464 | assert.Nil(t, c) |
||
| 465 | assert.Equal(t, "access_key_id cannot be empty", err.Error()) |
||
| 466 | //testcase 38, access_key_secret key does not exist |
||
| 467 | p = newProfileProvider("nostssecret") |
||
| 468 | c, err = p.resolve() |
||
| 469 | assert.Nil(t, c) |
||
| 470 | assert.Equal(t, "Missing required access_key_secret option in profile for sts", err.Error()) |
||
| 471 | //testcase 39, access_key_secret value is empty |
||
| 472 | p = newProfileProvider("emptystssecret") |
||
| 473 | c, err = p.resolve() |
||
| 474 | assert.Nil(t, c) |
||
| 475 | assert.Equal(t, "access_key_secret cannot be empty", err.Error()) |
||
| 476 | //testcase 40, security_token access_key_secretkey does not exist |
||
| 477 | p = newProfileProvider("noststoken") |
||
| 478 | c, err = p.resolve() |
||
| 479 | assert.Nil(t, c) |
||
| 480 | assert.Equal(t, "Missing required security_token option in profile for sts", err.Error()) |
||
| 481 | //testcase 41, security_token value is empty |
||
| 482 | p = newProfileProvider("emptyststoken") |
||
| 483 | c, err = p.resolve() |
||
| 484 | assert.Nil(t, c) |
||
| 485 | assert.Equal(t, "security_token cannot be empty", err.Error()) |
||
| 486 | |||
| 487 | //testcase 42, normal RamRoleArn |
||
| 488 | p = newProfileProvider("bearer") |
||
| 489 | c, err = p.resolve() |
||
| 490 | assert.Nil(t, err) |
||
| 491 | //testcase 43, key does not exist |
||
| 492 | p = newProfileProvider("nobearer") |
||
| 493 | c, err = p.resolve() |
||
| 494 | assert.Nil(t, c) |
||
| 495 | assert.Equal(t, "Missing required bearer_token option in profile for bearer", err.Error()) |
||
| 496 | //testcase 44, value is empty |
||
| 497 | p = newProfileProvider("emptybearer") |
||
| 498 | c, err = p.resolve() |
||
| 499 | assert.Nil(t, c) |
||
| 500 | assert.Equal(t, "bearer_token cannot be empty", err.Error()) |
||
| 501 | |||
| 502 | //testcase 45, credential type is error |
||
| 503 | p = newProfileProvider("error_type") |
||
| 504 | c, err = p.resolve() |
||
| 505 | assert.Nil(t, c) |
||
| 506 | assert.Equal(t, "Invalid type option, support: access_key, sts, ecs_ram_role, ram_role_arn, rsa_key_pair", err.Error()) |
||
| 507 | } |
||
| 548 |
