github.com/opentelekomcloud/gophertelekomcloud@v0.9.3/acceptance/openstack/elb/v3/policies_test.go (about)

     1  package v3
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/clients"
     7  	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/tools"
     8  	"github.com/opentelekomcloud/gophertelekomcloud/openstack/common/pointerto"
     9  	"github.com/opentelekomcloud/gophertelekomcloud/openstack/elb/v3/listeners"
    10  	"github.com/opentelekomcloud/gophertelekomcloud/openstack/elb/v3/policies"
    11  	th "github.com/opentelekomcloud/gophertelekomcloud/testhelper"
    12  )
    13  
    14  func TestPolicyWorkflow(t *testing.T) {
    15  	t.Parallel()
    16  
    17  	client, err := clients.NewElbV3Client()
    18  	th.AssertNoErr(t, err)
    19  
    20  	lbID := createLoadBalancer(t, client)
    21  	defer deleteLoadbalancer(t, client, lbID)
    22  
    23  	listenerID := createListener(t, client, lbID)
    24  	defer deleteListener(t, client, listenerID)
    25  
    26  	poolID := createPool(t, client, lbID)
    27  	defer deletePool(t, client, poolID)
    28  
    29  	createOpts := policies.CreateOpts{
    30  		Action:         policies.ActionRedirectToPool,
    31  		ListenerID:     listenerID,
    32  		RedirectPoolID: poolID,
    33  		Description:    "Go SDK test policy",
    34  		Name:           tools.RandomString("sdk-pol-", 5),
    35  		Position:       37,
    36  	}
    37  	created, err := policies.Create(client, createOpts).Extract()
    38  	th.AssertNoErr(t, err)
    39  	t.Logf("Created L7 Policy")
    40  	id := created.ID
    41  
    42  	defer func() {
    43  		th.AssertNoErr(t, policies.Delete(client, id).ExtractErr())
    44  		t.Log("Deleted L7 Policy")
    45  	}()
    46  
    47  	got, err := policies.Get(client, id).Extract()
    48  	th.AssertNoErr(t, err)
    49  	th.AssertDeepEquals(t, created, got)
    50  
    51  	listOpts := policies.ListOpts{
    52  		ListenerID: []string{listenerID},
    53  	}
    54  	pages, err := policies.List(client, listOpts).AllPages()
    55  	th.AssertNoErr(t, err)
    56  	policySlice, err := policies.ExtractPolicies(pages)
    57  	th.AssertNoErr(t, err)
    58  	th.AssertEquals(t, 1, len(policySlice))
    59  	th.AssertEquals(t, id, policySlice[0].ID)
    60  
    61  	nameUpdated := tools.RandomString("updated-", 5)
    62  	updateOpts := policies.UpdateOpts{
    63  		Name: &nameUpdated,
    64  	}
    65  	updated, err := policies.Update(client, id, updateOpts).Extract()
    66  	th.AssertNoErr(t, err)
    67  	t.Log("Updated l7 Policy")
    68  	th.AssertEquals(t, created.Action, updated.Action)
    69  	th.AssertEquals(t, id, updated.ID)
    70  
    71  	got2, _ := policies.Get(client, id).Extract()
    72  	th.AssertDeepEquals(t, updated, got2)
    73  }
    74  
    75  func TestPolicyWorkflowFixedResponse(t *testing.T) {
    76  	t.Parallel()
    77  
    78  	client, err := clients.NewElbV3Client()
    79  	th.AssertNoErr(t, err)
    80  
    81  	lbID := createLoadBalancer(t, client)
    82  	defer deleteLoadbalancer(t, client, lbID)
    83  
    84  	listener, err := listeners.Create(client, listeners.CreateOpts{
    85  		LoadbalancerID:  lbID,
    86  		Protocol:        listeners.ProtocolHTTP,
    87  		ProtocolPort:    80,
    88  		EnhanceL7policy: pointerto.Bool(true),
    89  	}).Extract()
    90  	th.AssertNoErr(t, err)
    91  	defer deleteListener(t, client, listener.ID)
    92  
    93  	poolID := createPool(t, client, lbID)
    94  	defer deletePool(t, client, poolID)
    95  
    96  	createOpts := policies.CreateOpts{
    97  		Action:     policies.ActionFixedResponse,
    98  		ListenerID: listener.ID,
    99  		FixedResponseConfig: &policies.FixedResponseOptions{
   100  			StatusCode:  "200",
   101  			ContentType: "text/plain",
   102  			MessageBody: "Fixed Response",
   103  		},
   104  		Description: "Go SDK test policy",
   105  		Name:        tools.RandomString("sdk-pol-", 5),
   106  		Position:    37,
   107  	}
   108  	created, err := policies.Create(client, createOpts).Extract()
   109  	th.AssertNoErr(t, err)
   110  	t.Logf("Created L7 Policy")
   111  	id := created.ID
   112  
   113  	defer func() {
   114  		th.AssertNoErr(t, policies.Delete(client, id).ExtractErr())
   115  		t.Log("Deleted L7 Policy")
   116  	}()
   117  
   118  	got, err := policies.Get(client, id).Extract()
   119  	th.AssertNoErr(t, err)
   120  	th.AssertDeepEquals(t, created, got)
   121  
   122  	listOpts := policies.ListOpts{
   123  		ListenerID: []string{listener.ID},
   124  	}
   125  	pages, err := policies.List(client, listOpts).AllPages()
   126  	th.AssertNoErr(t, err)
   127  	policySlice, err := policies.ExtractPolicies(pages)
   128  	th.AssertNoErr(t, err)
   129  	th.AssertEquals(t, 1, len(policySlice))
   130  	th.AssertEquals(t, id, policySlice[0].ID)
   131  
   132  	nameUpdated := tools.RandomString("updated-", 5)
   133  	updateOpts := policies.UpdateOpts{
   134  		Name: &nameUpdated,
   135  		FixedResponseConfig: &policies.FixedResponseOptions{
   136  			StatusCode:  "200",
   137  			ContentType: "text/plain",
   138  			MessageBody: "Fixed Response Update",
   139  		},
   140  	}
   141  	updated, err := policies.Update(client, id, updateOpts).Extract()
   142  	th.AssertNoErr(t, err)
   143  	t.Log("Updated l7 Policy")
   144  	th.AssertEquals(t, created.Action, updated.Action)
   145  	th.AssertEquals(t, id, updated.ID)
   146  
   147  	got2, _ := policies.Get(client, id).Extract()
   148  	th.AssertDeepEquals(t, updated, got2)
   149  }
   150  
   151  func TestPolicyWorkflowUlrRedirect(t *testing.T) {
   152  	t.Parallel()
   153  
   154  	client, err := clients.NewElbV3Client()
   155  	th.AssertNoErr(t, err)
   156  
   157  	lbID := createLoadBalancer(t, client)
   158  	defer deleteLoadbalancer(t, client, lbID)
   159  
   160  	listener, err := listeners.Create(client, listeners.CreateOpts{
   161  		LoadbalancerID:  lbID,
   162  		Protocol:        listeners.ProtocolHTTP,
   163  		ProtocolPort:    80,
   164  		EnhanceL7policy: pointerto.Bool(true),
   165  	}).Extract()
   166  	th.AssertNoErr(t, err)
   167  	defer deleteListener(t, client, listener.ID)
   168  
   169  	poolID := createPool(t, client, lbID)
   170  	defer deletePool(t, client, poolID)
   171  
   172  	createOpts := policies.CreateOpts{
   173  		Action:      policies.ActionUrlRedirect,
   174  		ListenerID:  listener.ID,
   175  		RedirectUrl: "https://www.bing.com:443",
   176  		RedirectUrlConfig: &policies.RedirectUrlOptions{
   177  			StatusCode: "302",
   178  			Protocol:   "${protocol}",
   179  			Port:       "${port}",
   180  			Path:       "${path}",
   181  			Query:      "${query}&name=my_name",
   182  			Host:       "${host}",
   183  		},
   184  		Description: "Go SDK test policy",
   185  		Name:        tools.RandomString("sdk-pol-", 5),
   186  		Position:    37,
   187  	}
   188  	created, err := policies.Create(client, createOpts).Extract()
   189  	th.AssertNoErr(t, err)
   190  	t.Logf("Created L7 Policy")
   191  	id := created.ID
   192  
   193  	defer func() {
   194  		th.AssertNoErr(t, policies.Delete(client, id).ExtractErr())
   195  		t.Log("Deleted L7 Policy")
   196  	}()
   197  
   198  	got, err := policies.Get(client, id).Extract()
   199  	th.AssertNoErr(t, err)
   200  	th.AssertDeepEquals(t, created, got)
   201  
   202  	listOpts := policies.ListOpts{
   203  		ListenerID: []string{listener.ID},
   204  	}
   205  	pages, err := policies.List(client, listOpts).AllPages()
   206  	th.AssertNoErr(t, err)
   207  	policySlice, err := policies.ExtractPolicies(pages)
   208  	th.AssertNoErr(t, err)
   209  	th.AssertEquals(t, 1, len(policySlice))
   210  	th.AssertEquals(t, id, policySlice[0].ID)
   211  
   212  	nameUpdated := tools.RandomString("updated-", 5)
   213  	updateOpts := policies.UpdateOpts{
   214  		Name: &nameUpdated,
   215  		RedirectUrlConfig: &policies.RedirectUrlOptions{
   216  			StatusCode: "308",
   217  			Protocol:   "${protocol}",
   218  			Port:       "${port}",
   219  			Path:       "${path}",
   220  			Query:      "${query}&name=my_name",
   221  			Host:       "${host}",
   222  		},
   223  	}
   224  	updated, err := policies.Update(client, id, updateOpts).Extract()
   225  	th.AssertNoErr(t, err)
   226  	t.Log("Updated l7 Policy")
   227  	th.AssertEquals(t, created.Action, updated.Action)
   228  	th.AssertEquals(t, id, updated.ID)
   229  
   230  	got2, _ := policies.Get(client, id).Extract()
   231  	th.AssertDeepEquals(t, updated, got2)
   232  }