github.com/vnpaycloud-console/gophercloud/v2@v2.0.5/internal/acceptance/openstack/client_test.go (about)

     1  //go:build acceptance
     2  
     3  package openstack
     4  
     5  import (
     6  	"context"
     7  	"os"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/vnpaycloud-console/gophercloud/v2"
    12  	"github.com/vnpaycloud-console/gophercloud/v2/internal/acceptance/clients"
    13  	"github.com/vnpaycloud-console/gophercloud/v2/internal/acceptance/tools"
    14  	"github.com/vnpaycloud-console/gophercloud/v2/openstack"
    15  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/identity/v3/credentials"
    16  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/identity/v3/ec2tokens"
    17  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/identity/v3/tokens"
    18  	th "github.com/vnpaycloud-console/gophercloud/v2/testhelper"
    19  )
    20  
    21  func TestAuthenticatedClient(t *testing.T) {
    22  	// Obtain credentials from the environment.
    23  	ao, err := openstack.AuthOptionsFromEnv()
    24  	if err != nil {
    25  		t.Fatalf("Unable to acquire credentials: %v", err)
    26  	}
    27  
    28  	client, err := openstack.AuthenticatedClient(context.TODO(), ao)
    29  	if err != nil {
    30  		t.Fatalf("Unable to authenticate: %v", err)
    31  	}
    32  
    33  	if client.TokenID == "" {
    34  		t.Errorf("No token ID assigned to the client")
    35  	}
    36  
    37  	t.Logf("Client successfully acquired a token: %v", client.TokenID)
    38  
    39  	// Find the storage service in the service catalog.
    40  	storage, err := openstack.NewObjectStorageV1(client, gophercloud.EndpointOpts{
    41  		Region: os.Getenv("OS_REGION_NAME"),
    42  	})
    43  	if err != nil {
    44  		t.Errorf("Unable to locate a storage service: %v", err)
    45  	} else {
    46  		t.Logf("Located a storage service at endpoint: [%s]", storage.Endpoint)
    47  	}
    48  }
    49  
    50  func TestEC2AuthMethod(t *testing.T) {
    51  	client, err := clients.NewIdentityV3Client()
    52  	th.AssertNoErr(t, err)
    53  
    54  	ao, err := openstack.AuthOptionsFromEnv()
    55  	th.AssertNoErr(t, err)
    56  
    57  	authOptions := tokens.AuthOptions{
    58  		Username:   ao.Username,
    59  		UserID:     ao.UserID,
    60  		Password:   ao.Password,
    61  		DomainName: ao.DomainName,
    62  		DomainID:   ao.DomainID,
    63  		Scope: tokens.Scope{
    64  			ProjectID:   ao.TenantID,
    65  			ProjectName: ao.TenantName,
    66  			DomainID:    ao.DomainID,
    67  			DomainName:  ao.DomainName,
    68  		},
    69  	}
    70  	token, err := tokens.Create(context.TODO(), client, &authOptions).Extract()
    71  	th.AssertNoErr(t, err)
    72  	tools.PrintResource(t, token)
    73  
    74  	user, err := tokens.Get(context.TODO(), client, token.ID).ExtractUser()
    75  	th.AssertNoErr(t, err)
    76  	tools.PrintResource(t, user)
    77  
    78  	project, err := tokens.Get(context.TODO(), client, token.ID).ExtractProject()
    79  	th.AssertNoErr(t, err)
    80  	tools.PrintResource(t, project)
    81  
    82  	createOpts := credentials.CreateOpts{
    83  		ProjectID: project.ID,
    84  		Type:      "ec2",
    85  		UserID:    user.ID,
    86  		Blob:      "{\"access\":\"181920\",\"secret\":\"secretKey\"}",
    87  	}
    88  
    89  	// Create a credential
    90  	credential, err := credentials.Create(context.TODO(), client, createOpts).Extract()
    91  	th.AssertNoErr(t, err)
    92  
    93  	// Delete a credential
    94  	defer credentials.Delete(context.TODO(), client, credential.ID)
    95  	tools.PrintResource(t, credential)
    96  
    97  	newClient, err := clients.NewIdentityV3UnauthenticatedClient()
    98  	th.AssertNoErr(t, err)
    99  
   100  	ec2AuthOptions := &ec2tokens.AuthOptions{
   101  		Access: "181920",
   102  		Secret: "secretKey",
   103  	}
   104  
   105  	err = openstack.AuthenticateV3(context.TODO(), newClient.ProviderClient, ec2AuthOptions, gophercloud.EndpointOpts{})
   106  	th.AssertNoErr(t, err)
   107  
   108  	tools.PrintResource(t, newClient.TokenID)
   109  }
   110  
   111  func TestReauth(t *testing.T) {
   112  	ao, err := openstack.AuthOptionsFromEnv()
   113  	if err != nil {
   114  		t.Fatalf("Unable to obtain environment auth options: %v", err)
   115  	}
   116  
   117  	// Allow reauth
   118  	ao.AllowReauth = true
   119  
   120  	provider, err := openstack.NewClient(ao.IdentityEndpoint)
   121  	if err != nil {
   122  		t.Fatalf("Unable to create provider: %v", err)
   123  	}
   124  
   125  	err = openstack.Authenticate(context.TODO(), provider, ao)
   126  	if err != nil {
   127  		t.Fatalf("Unable to authenticate: %v", err)
   128  	}
   129  
   130  	t.Logf("Creating a compute client")
   131  	_, err = openstack.NewComputeV2(provider, gophercloud.EndpointOpts{
   132  		Region: os.Getenv("OS_REGION_NAME"),
   133  	})
   134  	if err != nil {
   135  		t.Fatalf("Unable to create compute client: %v", err)
   136  	}
   137  
   138  	t.Logf("Sleeping for 1 second")
   139  	time.Sleep(1 * time.Second)
   140  	t.Logf("Attempting to reauthenticate")
   141  
   142  	err = provider.ReauthFunc(context.TODO())
   143  	if err != nil {
   144  		t.Fatalf("Unable to reauthenticate: %v", err)
   145  	}
   146  
   147  	t.Logf("Creating a compute client")
   148  	_, err = openstack.NewComputeV2(provider, gophercloud.EndpointOpts{
   149  		Region: os.Getenv("OS_REGION_NAME"),
   150  	})
   151  	if err != nil {
   152  		t.Fatalf("Unable to create compute client: %v", err)
   153  	}
   154  }