github.com/gophercloud/gophercloud@v1.11.0/internal/acceptance/openstack/identity/v3/credentials_test.go (about)

     1  //go:build acceptance
     2  // +build acceptance
     3  
     4  package v3
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/gophercloud/gophercloud/internal/acceptance/clients"
    10  	"github.com/gophercloud/gophercloud/internal/acceptance/tools"
    11  	"github.com/gophercloud/gophercloud/openstack"
    12  	"github.com/gophercloud/gophercloud/openstack/identity/v3/credentials"
    13  	"github.com/gophercloud/gophercloud/openstack/identity/v3/extensions/ec2tokens"
    14  	"github.com/gophercloud/gophercloud/openstack/identity/v3/tokens"
    15  	th "github.com/gophercloud/gophercloud/testhelper"
    16  )
    17  
    18  func TestCredentialsCRUD(t *testing.T) {
    19  	client, err := clients.NewIdentityV3Client()
    20  	th.AssertNoErr(t, err)
    21  
    22  	ao, err := openstack.AuthOptionsFromEnv()
    23  	th.AssertNoErr(t, err)
    24  
    25  	authOptions := tokens.AuthOptions{
    26  		Username:   ao.Username,
    27  		Password:   ao.Password,
    28  		DomainName: ao.DomainName,
    29  		DomainID:   ao.DomainID,
    30  		// We need a scope to get the token roles list
    31  		Scope: tokens.Scope{
    32  			ProjectID:   ao.TenantID,
    33  			ProjectName: ao.TenantName,
    34  			DomainID:    ao.DomainID,
    35  			DomainName:  ao.DomainName,
    36  		},
    37  	}
    38  	token, err := tokens.Create(client, &authOptions).Extract()
    39  	th.AssertNoErr(t, err)
    40  	tools.PrintResource(t, token)
    41  
    42  	user, err := tokens.Get(client, token.ID).ExtractUser()
    43  	th.AssertNoErr(t, err)
    44  	tools.PrintResource(t, user)
    45  
    46  	project, err := tokens.Get(client, token.ID).ExtractProject()
    47  	th.AssertNoErr(t, err)
    48  	tools.PrintResource(t, project)
    49  
    50  	createOpts := credentials.CreateOpts{
    51  		ProjectID: project.ID,
    52  		Type:      "ec2",
    53  		UserID:    user.ID,
    54  		Blob:      "{\"access\":\"181920\",\"secret\":\"secretKey\"}",
    55  	}
    56  
    57  	// Create a credential
    58  	credential, err := credentials.Create(client, createOpts).Extract()
    59  	th.AssertNoErr(t, err)
    60  
    61  	// Delete a credential
    62  	defer credentials.Delete(client, credential.ID)
    63  	tools.PrintResource(t, credential)
    64  
    65  	th.AssertEquals(t, credential.Blob, createOpts.Blob)
    66  	th.AssertEquals(t, credential.Type, createOpts.Type)
    67  	th.AssertEquals(t, credential.UserID, createOpts.UserID)
    68  	th.AssertEquals(t, credential.ProjectID, createOpts.ProjectID)
    69  
    70  	// Get a credential
    71  	getCredential, err := credentials.Get(client, credential.ID).Extract()
    72  	th.AssertNoErr(t, err)
    73  	tools.PrintResource(t, getCredential)
    74  
    75  	th.AssertEquals(t, getCredential.Blob, createOpts.Blob)
    76  	th.AssertEquals(t, getCredential.Type, createOpts.Type)
    77  	th.AssertEquals(t, getCredential.UserID, createOpts.UserID)
    78  	th.AssertEquals(t, getCredential.ProjectID, createOpts.ProjectID)
    79  
    80  	updateOpts := credentials.UpdateOpts{
    81  		ProjectID: project.ID,
    82  		Type:      "ec2",
    83  		UserID:    user.ID,
    84  		Blob:      "{\"access\":\"181920\",\"secret\":\"mySecret\"}",
    85  	}
    86  
    87  	// Update a credential
    88  	updateCredential, err := credentials.Update(client, credential.ID, updateOpts).Extract()
    89  	th.AssertNoErr(t, err)
    90  	tools.PrintResource(t, updateCredential)
    91  
    92  	th.AssertEquals(t, updateCredential.Blob, updateOpts.Blob)
    93  }
    94  
    95  func TestCredentialsValidateS3(t *testing.T) {
    96  	client, err := clients.NewIdentityV3Client()
    97  	th.AssertNoErr(t, err)
    98  
    99  	ao, err := openstack.AuthOptionsFromEnv()
   100  	th.AssertNoErr(t, err)
   101  
   102  	authOptions := tokens.AuthOptions{
   103  		Username:   ao.Username,
   104  		Password:   ao.Password,
   105  		DomainName: ao.DomainName,
   106  		DomainID:   ao.DomainID,
   107  		// We need a scope to get the token roles list
   108  		Scope: tokens.Scope{
   109  			ProjectID:   ao.TenantID,
   110  			ProjectName: ao.TenantName,
   111  			DomainID:    ao.DomainID,
   112  			DomainName:  ao.DomainName,
   113  		},
   114  	}
   115  	token, err := tokens.Create(client, &authOptions).Extract()
   116  	th.AssertNoErr(t, err)
   117  	tools.PrintResource(t, token)
   118  
   119  	user, err := tokens.Get(client, token.ID).ExtractUser()
   120  	th.AssertNoErr(t, err)
   121  	tools.PrintResource(t, user)
   122  
   123  	project, err := tokens.Get(client, token.ID).ExtractProject()
   124  	th.AssertNoErr(t, err)
   125  	tools.PrintResource(t, project)
   126  
   127  	createOpts := credentials.CreateOpts{
   128  		ProjectID: project.ID,
   129  		Type:      "ec2",
   130  		UserID:    user.ID,
   131  		Blob:      "{\"access\":\"181920\",\"secret\":\"secretKey\"}",
   132  	}
   133  
   134  	// Create a credential
   135  	credential, err := credentials.Create(client, createOpts).Extract()
   136  	th.AssertNoErr(t, err)
   137  
   138  	// Delete a credential
   139  	defer credentials.Delete(client, credential.ID)
   140  	tools.PrintResource(t, credential)
   141  
   142  	th.AssertEquals(t, credential.Blob, createOpts.Blob)
   143  	th.AssertEquals(t, credential.Type, createOpts.Type)
   144  	th.AssertEquals(t, credential.UserID, createOpts.UserID)
   145  	th.AssertEquals(t, credential.ProjectID, createOpts.ProjectID)
   146  
   147  	opts := ec2tokens.AuthOptions{
   148  		Access: "181920",
   149  		Secret: "secretKey",
   150  		// auth will fail if this is not s3
   151  		Service: "s3",
   152  	}
   153  
   154  	// Validate a credential
   155  	token, err = ec2tokens.ValidateS3Token(client, &opts).Extract()
   156  	th.AssertNoErr(t, err)
   157  	tools.PrintResource(t, token)
   158  }