github.com/gophercloud/gophercloud@v1.11.0/internal/acceptance/openstack/networking/v2/extensions/qos/rules/rules_test.go (about)

     1  package rules
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/gophercloud/gophercloud/internal/acceptance/clients"
     7  	accpolicies "github.com/gophercloud/gophercloud/internal/acceptance/openstack/networking/v2/extensions/qos/policies"
     8  	"github.com/gophercloud/gophercloud/internal/acceptance/tools"
     9  	"github.com/gophercloud/gophercloud/openstack/common/extensions"
    10  	"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/qos/policies"
    11  	"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/qos/rules"
    12  	th "github.com/gophercloud/gophercloud/testhelper"
    13  )
    14  
    15  func TestBandwidthLimitRulesCRUD(t *testing.T) {
    16  	client, err := clients.NewNetworkV2Client()
    17  	th.AssertNoErr(t, err)
    18  
    19  	extension, err := extensions.Get(client, "qos").Extract()
    20  	if err != nil {
    21  		t.Skip("This test requires qos Neutron extension")
    22  	}
    23  	tools.PrintResource(t, extension)
    24  
    25  	// Create a QoS policy
    26  	policy, err := accpolicies.CreateQoSPolicy(t, client)
    27  	th.AssertNoErr(t, err)
    28  	defer policies.Delete(client, policy.ID)
    29  
    30  	tools.PrintResource(t, policy)
    31  
    32  	// Create a QoS policy rule.
    33  	rule, err := CreateBandwidthLimitRule(t, client, policy.ID)
    34  	th.AssertNoErr(t, err)
    35  	defer rules.DeleteBandwidthLimitRule(client, policy.ID, rule.ID)
    36  
    37  	// Update the QoS policy rule.
    38  	newMaxBurstKBps := 0
    39  	updateOpts := rules.UpdateBandwidthLimitRuleOpts{
    40  		MaxBurstKBps: &newMaxBurstKBps,
    41  	}
    42  	newRule, err := rules.UpdateBandwidthLimitRule(client, policy.ID, rule.ID, updateOpts).ExtractBandwidthLimitRule()
    43  	th.AssertNoErr(t, err)
    44  
    45  	tools.PrintResource(t, newRule)
    46  	th.AssertEquals(t, newRule.MaxBurstKBps, 0)
    47  
    48  	allPages, err := rules.ListBandwidthLimitRules(client, policy.ID, rules.BandwidthLimitRulesListOpts{}).AllPages()
    49  	th.AssertNoErr(t, err)
    50  
    51  	allRules, err := rules.ExtractBandwidthLimitRules(allPages)
    52  	th.AssertNoErr(t, err)
    53  
    54  	var found bool
    55  	for _, rule := range allRules {
    56  		if rule.ID == newRule.ID {
    57  			found = true
    58  		}
    59  	}
    60  
    61  	th.AssertEquals(t, found, true)
    62  }
    63  
    64  func TestDSCPMarkingRulesCRUD(t *testing.T) {
    65  	client, err := clients.NewNetworkV2Client()
    66  	th.AssertNoErr(t, err)
    67  
    68  	extension, err := extensions.Get(client, "qos").Extract()
    69  	if err != nil {
    70  		t.Skip("This test requires qos Neutron extension")
    71  	}
    72  	tools.PrintResource(t, extension)
    73  
    74  	// Create a QoS policy
    75  	policy, err := accpolicies.CreateQoSPolicy(t, client)
    76  	th.AssertNoErr(t, err)
    77  	defer policies.Delete(client, policy.ID)
    78  
    79  	tools.PrintResource(t, policy)
    80  
    81  	// Create a QoS policy rule.
    82  	rule, err := CreateDSCPMarkingRule(t, client, policy.ID)
    83  	th.AssertNoErr(t, err)
    84  	defer rules.DeleteDSCPMarkingRule(client, policy.ID, rule.ID)
    85  
    86  	// Update the QoS policy rule.
    87  	dscpMark := 20
    88  	updateOpts := rules.UpdateDSCPMarkingRuleOpts{
    89  		DSCPMark: &dscpMark,
    90  	}
    91  	newRule, err := rules.UpdateDSCPMarkingRule(client, policy.ID, rule.ID, updateOpts).ExtractDSCPMarkingRule()
    92  	th.AssertNoErr(t, err)
    93  
    94  	tools.PrintResource(t, newRule)
    95  	th.AssertEquals(t, newRule.DSCPMark, 20)
    96  
    97  	allPages, err := rules.ListDSCPMarkingRules(client, policy.ID, rules.DSCPMarkingRulesListOpts{}).AllPages()
    98  	th.AssertNoErr(t, err)
    99  
   100  	allRules, err := rules.ExtractDSCPMarkingRules(allPages)
   101  	th.AssertNoErr(t, err)
   102  
   103  	var found bool
   104  	for _, rule := range allRules {
   105  		if rule.ID == newRule.ID {
   106  			found = true
   107  		}
   108  	}
   109  
   110  	th.AssertEquals(t, found, true)
   111  }
   112  
   113  func TestMinimumBandwidthRulesCRUD(t *testing.T) {
   114  	client, err := clients.NewNetworkV2Client()
   115  	th.AssertNoErr(t, err)
   116  
   117  	extension, err := extensions.Get(client, "qos").Extract()
   118  	if err != nil {
   119  		t.Skip("This test requires qos Neutron extension")
   120  	}
   121  	tools.PrintResource(t, extension)
   122  
   123  	// Create a QoS policy
   124  	policy, err := accpolicies.CreateQoSPolicy(t, client)
   125  	th.AssertNoErr(t, err)
   126  	defer policies.Delete(client, policy.ID)
   127  
   128  	tools.PrintResource(t, policy)
   129  
   130  	// Create a QoS policy rule.
   131  	rule, err := CreateMinimumBandwidthRule(t, client, policy.ID)
   132  	th.AssertNoErr(t, err)
   133  	defer rules.DeleteMinimumBandwidthRule(client, policy.ID, rule.ID)
   134  
   135  	// Update the QoS policy rule.
   136  	minKBps := 500
   137  	updateOpts := rules.UpdateMinimumBandwidthRuleOpts{
   138  		MinKBps: &minKBps,
   139  	}
   140  	newRule, err := rules.UpdateMinimumBandwidthRule(client, policy.ID, rule.ID, updateOpts).ExtractMinimumBandwidthRule()
   141  	th.AssertNoErr(t, err)
   142  
   143  	tools.PrintResource(t, newRule)
   144  	th.AssertEquals(t, newRule.MinKBps, 500)
   145  
   146  	allPages, err := rules.ListMinimumBandwidthRules(client, policy.ID, rules.MinimumBandwidthRulesListOpts{}).AllPages()
   147  	th.AssertNoErr(t, err)
   148  
   149  	allRules, err := rules.ExtractMinimumBandwidthRules(allPages)
   150  	th.AssertNoErr(t, err)
   151  
   152  	var found bool
   153  	for _, rule := range allRules {
   154  		if rule.ID == newRule.ID {
   155  			found = true
   156  		}
   157  	}
   158  
   159  	th.AssertEquals(t, found, true)
   160  }