github.com/vnpaycloud-console/gophercloud/v2@v2.0.5/openstack/messaging/v2/queues/testing/requests_test.go (about)

     1  package testing
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/messaging/v2/queues"
     8  	"github.com/vnpaycloud-console/gophercloud/v2/pagination"
     9  	th "github.com/vnpaycloud-console/gophercloud/v2/testhelper"
    10  	fake "github.com/vnpaycloud-console/gophercloud/v2/testhelper/client"
    11  )
    12  
    13  func TestList(t *testing.T) {
    14  	th.SetupHTTP()
    15  	defer th.TeardownHTTP()
    16  	HandleListSuccessfully(t)
    17  
    18  	listOpts := queues.ListOpts{
    19  		Limit:     1,
    20  		WithCount: true,
    21  	}
    22  
    23  	count := 0
    24  	err := queues.List(fake.ServiceClient(), listOpts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
    25  		actual, err := queues.ExtractQueues(page)
    26  		th.AssertNoErr(t, err)
    27  		countField, err := page.(queues.QueuePage).GetCount()
    28  
    29  		th.AssertNoErr(t, err)
    30  		th.AssertEquals(t, countField, 2)
    31  
    32  		th.CheckDeepEquals(t, ExpectedQueueSlice[count], actual)
    33  		count++
    34  		return true, nil
    35  	})
    36  	th.AssertNoErr(t, err)
    37  
    38  	th.CheckEquals(t, 2, count)
    39  }
    40  
    41  func TestCreate(t *testing.T) {
    42  	th.SetupHTTP()
    43  	defer th.TeardownHTTP()
    44  	HandleCreateSuccessfully(t)
    45  	var enableEncrypted *bool = new(bool)
    46  
    47  	createOpts := queues.CreateOpts{
    48  		QueueName:                  QueueName,
    49  		MaxMessagesPostSize:        262144,
    50  		DefaultMessageTTL:          3600,
    51  		DefaultMessageDelay:        30,
    52  		DeadLetterQueue:            "dead_letter",
    53  		DeadLetterQueueMessagesTTL: 3600,
    54  		MaxClaimCount:              10,
    55  		EnableEncryptMessages:      enableEncrypted,
    56  		Extra:                      map[string]any{"description": "Queue for unit testing."},
    57  	}
    58  
    59  	err := queues.Create(context.TODO(), fake.ServiceClient(), createOpts).ExtractErr()
    60  	th.AssertNoErr(t, err)
    61  }
    62  
    63  func TestUpdate(t *testing.T) {
    64  	th.SetupHTTP()
    65  	defer th.TeardownHTTP()
    66  	HandleUpdateSuccessfully(t)
    67  
    68  	updateOpts := queues.BatchUpdateOpts{
    69  		queues.UpdateOpts{
    70  			Op:    queues.ReplaceOp,
    71  			Path:  "/metadata/description",
    72  			Value: "Update queue description",
    73  		},
    74  	}
    75  	updatedQueueResult := queues.QueueDetails{
    76  		Extra: map[string]any{"description": "Update queue description"},
    77  	}
    78  
    79  	actual, err := queues.Update(context.TODO(), fake.ServiceClient(), QueueName, updateOpts).Extract()
    80  	th.AssertNoErr(t, err)
    81  	th.CheckDeepEquals(t, updatedQueueResult, actual)
    82  }
    83  
    84  func TestGet(t *testing.T) {
    85  	th.SetupHTTP()
    86  	defer th.TeardownHTTP()
    87  	HandleGetSuccessfully(t)
    88  
    89  	actual, err := queues.Get(context.TODO(), fake.ServiceClient(), QueueName).Extract()
    90  	th.AssertNoErr(t, err)
    91  	th.CheckDeepEquals(t, QueueDetails, actual)
    92  }
    93  
    94  func TestDelete(t *testing.T) {
    95  	th.SetupHTTP()
    96  	defer th.TeardownHTTP()
    97  	HandleDeleteSuccessfully(t)
    98  
    99  	err := queues.Delete(context.TODO(), fake.ServiceClient(), QueueName).ExtractErr()
   100  	th.AssertNoErr(t, err)
   101  }
   102  
   103  func TestGetStat(t *testing.T) {
   104  	th.SetupHTTP()
   105  	defer th.TeardownHTTP()
   106  	HandleGetStatsSuccessfully(t)
   107  
   108  	actual, err := queues.GetStats(context.TODO(), fake.ServiceClient(), QueueName).Extract()
   109  	th.AssertNoErr(t, err)
   110  	th.CheckDeepEquals(t, ExpectedStats, actual)
   111  }
   112  
   113  func TestShare(t *testing.T) {
   114  	th.SetupHTTP()
   115  	defer th.TeardownHTTP()
   116  	HandleShareSuccessfully(t)
   117  
   118  	shareOpts := queues.ShareOpts{
   119  		Paths:   []queues.SharePath{queues.PathMessages, queues.PathClaims, queues.PathSubscriptions},
   120  		Methods: []queues.ShareMethod{queues.MethodGet, queues.MethodPost, queues.MethodPut, queues.MethodPatch},
   121  		Expires: "2016-09-01T00:00:00",
   122  	}
   123  
   124  	actual, err := queues.Share(context.TODO(), fake.ServiceClient(), QueueName, shareOpts).Extract()
   125  	th.AssertNoErr(t, err)
   126  	th.CheckDeepEquals(t, ExpectedShare, actual)
   127  }
   128  
   129  func TestPurge(t *testing.T) {
   130  	th.SetupHTTP()
   131  	defer th.TeardownHTTP()
   132  	HandlePurgeSuccessfully(t)
   133  
   134  	purgeOpts := queues.PurgeOpts{
   135  		ResourceTypes: []queues.PurgeResource{queues.ResourceMessages, queues.ResourceSubscriptions},
   136  	}
   137  
   138  	err := queues.Purge(context.TODO(), fake.ServiceClient(), QueueName, purgeOpts).ExtractErr()
   139  	th.AssertNoErr(t, err)
   140  }