github.com/gophercloud/gophercloud@v1.11.0/openstack/messaging/v2/queues/testing/requests_test.go (about)

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