github.com/gophercloud/gophercloud@v1.11.0/openstack/compute/v2/extensions/secgroups/testing/requests_test.go (about)

     1  package testing
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/secgroups"
     7  	"github.com/gophercloud/gophercloud/pagination"
     8  	th "github.com/gophercloud/gophercloud/testhelper"
     9  	"github.com/gophercloud/gophercloud/testhelper/client"
    10  )
    11  
    12  const (
    13  	serverID = "{serverID}"
    14  	groupID  = "{groupID}"
    15  	ruleID   = "{ruleID}"
    16  )
    17  
    18  func TestList(t *testing.T) {
    19  	th.SetupHTTP()
    20  	defer th.TeardownHTTP()
    21  
    22  	mockListGroupsResponse(t)
    23  
    24  	count := 0
    25  
    26  	err := secgroups.List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
    27  		count++
    28  		actual, err := secgroups.ExtractSecurityGroups(page)
    29  		if err != nil {
    30  			t.Errorf("Failed to extract users: %v", err)
    31  			return false, err
    32  		}
    33  
    34  		expected := []secgroups.SecurityGroup{
    35  			{
    36  				ID:          groupID,
    37  				Description: "default",
    38  				Name:        "default",
    39  				Rules:       []secgroups.Rule{},
    40  				TenantID:    "openstack",
    41  			},
    42  		}
    43  
    44  		th.CheckDeepEquals(t, expected, actual)
    45  
    46  		return true, nil
    47  	})
    48  
    49  	th.AssertNoErr(t, err)
    50  	th.AssertEquals(t, 1, count)
    51  }
    52  
    53  func TestListByServer(t *testing.T) {
    54  	th.SetupHTTP()
    55  	defer th.TeardownHTTP()
    56  
    57  	mockListGroupsByServerResponse(t, serverID)
    58  
    59  	count := 0
    60  
    61  	err := secgroups.ListByServer(client.ServiceClient(), serverID).EachPage(func(page pagination.Page) (bool, error) {
    62  		count++
    63  		actual, err := secgroups.ExtractSecurityGroups(page)
    64  		if err != nil {
    65  			t.Errorf("Failed to extract users: %v", err)
    66  			return false, err
    67  		}
    68  
    69  		expected := []secgroups.SecurityGroup{
    70  			{
    71  				ID:          groupID,
    72  				Description: "default",
    73  				Name:        "default",
    74  				Rules:       []secgroups.Rule{},
    75  				TenantID:    "openstack",
    76  			},
    77  		}
    78  
    79  		th.CheckDeepEquals(t, expected, actual)
    80  
    81  		return true, nil
    82  	})
    83  
    84  	th.AssertNoErr(t, err)
    85  	th.AssertEquals(t, 1, count)
    86  }
    87  
    88  func TestCreate(t *testing.T) {
    89  	th.SetupHTTP()
    90  	defer th.TeardownHTTP()
    91  
    92  	mockCreateGroupResponse(t)
    93  
    94  	opts := secgroups.CreateOpts{
    95  		Name:        "test",
    96  		Description: "something",
    97  	}
    98  
    99  	group, err := secgroups.Create(client.ServiceClient(), opts).Extract()
   100  	th.AssertNoErr(t, err)
   101  
   102  	expected := &secgroups.SecurityGroup{
   103  		ID:          groupID,
   104  		Name:        "test",
   105  		Description: "something",
   106  		TenantID:    "openstack",
   107  		Rules:       []secgroups.Rule{},
   108  	}
   109  	th.AssertDeepEquals(t, expected, group)
   110  }
   111  
   112  func TestUpdate(t *testing.T) {
   113  	th.SetupHTTP()
   114  	defer th.TeardownHTTP()
   115  
   116  	mockUpdateGroupResponse(t, groupID)
   117  
   118  	description := "new_desc"
   119  	opts := secgroups.UpdateOpts{
   120  		Name:        "new_name",
   121  		Description: &description,
   122  	}
   123  
   124  	group, err := secgroups.Update(client.ServiceClient(), groupID, opts).Extract()
   125  	th.AssertNoErr(t, err)
   126  
   127  	expected := &secgroups.SecurityGroup{
   128  		ID:          groupID,
   129  		Name:        "new_name",
   130  		Description: "something",
   131  		TenantID:    "openstack",
   132  		Rules:       []secgroups.Rule{},
   133  	}
   134  	th.AssertDeepEquals(t, expected, group)
   135  }
   136  
   137  func TestGet(t *testing.T) {
   138  	th.SetupHTTP()
   139  	defer th.TeardownHTTP()
   140  
   141  	mockGetGroupsResponse(t, groupID)
   142  
   143  	group, err := secgroups.Get(client.ServiceClient(), groupID).Extract()
   144  	th.AssertNoErr(t, err)
   145  
   146  	expected := &secgroups.SecurityGroup{
   147  		ID:          groupID,
   148  		Description: "default",
   149  		Name:        "default",
   150  		TenantID:    "openstack",
   151  		Rules: []secgroups.Rule{
   152  			{
   153  				FromPort:      80,
   154  				ToPort:        85,
   155  				IPProtocol:    "TCP",
   156  				IPRange:       secgroups.IPRange{CIDR: "0.0.0.0"},
   157  				Group:         secgroups.Group{TenantID: "openstack", Name: "default"},
   158  				ParentGroupID: groupID,
   159  				ID:            ruleID,
   160  			},
   161  		},
   162  	}
   163  
   164  	th.AssertDeepEquals(t, expected, group)
   165  }
   166  
   167  func TestGetNumericID(t *testing.T) {
   168  	th.SetupHTTP()
   169  	defer th.TeardownHTTP()
   170  
   171  	numericGroupID := 12345
   172  
   173  	mockGetNumericIDGroupResponse(t, numericGroupID)
   174  
   175  	group, err := secgroups.Get(client.ServiceClient(), "12345").Extract()
   176  	th.AssertNoErr(t, err)
   177  
   178  	expected := &secgroups.SecurityGroup{ID: "12345"}
   179  	th.AssertDeepEquals(t, expected, group)
   180  }
   181  
   182  func TestGetNumericRuleID(t *testing.T) {
   183  	th.SetupHTTP()
   184  	defer th.TeardownHTTP()
   185  
   186  	numericGroupID := 12345
   187  
   188  	mockGetNumericIDGroupRuleResponse(t, numericGroupID)
   189  
   190  	group, err := secgroups.Get(client.ServiceClient(), "12345").Extract()
   191  	th.AssertNoErr(t, err)
   192  
   193  	expected := &secgroups.SecurityGroup{
   194  		ID: "12345",
   195  		Rules: []secgroups.Rule{
   196  			{
   197  				ParentGroupID: "12345",
   198  				ID:            "12345",
   199  			},
   200  		},
   201  	}
   202  	th.AssertDeepEquals(t, expected, group)
   203  }
   204  
   205  func TestDelete(t *testing.T) {
   206  	th.SetupHTTP()
   207  	defer th.TeardownHTTP()
   208  
   209  	mockDeleteGroupResponse(t, groupID)
   210  
   211  	err := secgroups.Delete(client.ServiceClient(), groupID).ExtractErr()
   212  	th.AssertNoErr(t, err)
   213  }
   214  
   215  func TestAddRule(t *testing.T) {
   216  	th.SetupHTTP()
   217  	defer th.TeardownHTTP()
   218  
   219  	mockAddRuleResponse(t)
   220  
   221  	opts := secgroups.CreateRuleOpts{
   222  		ParentGroupID: groupID,
   223  		FromPort:      22,
   224  		ToPort:        22,
   225  		IPProtocol:    "TCP",
   226  		CIDR:          "0.0.0.0/0",
   227  	}
   228  
   229  	rule, err := secgroups.CreateRule(client.ServiceClient(), opts).Extract()
   230  	th.AssertNoErr(t, err)
   231  
   232  	expected := &secgroups.Rule{
   233  		FromPort:      22,
   234  		ToPort:        22,
   235  		Group:         secgroups.Group{},
   236  		IPProtocol:    "TCP",
   237  		ParentGroupID: groupID,
   238  		IPRange:       secgroups.IPRange{CIDR: "0.0.0.0/0"},
   239  		ID:            ruleID,
   240  	}
   241  
   242  	th.AssertDeepEquals(t, expected, rule)
   243  }
   244  
   245  func TestAddRuleICMPZero(t *testing.T) {
   246  	th.SetupHTTP()
   247  	defer th.TeardownHTTP()
   248  
   249  	mockAddRuleResponseICMPZero(t)
   250  
   251  	opts := secgroups.CreateRuleOpts{
   252  		ParentGroupID: groupID,
   253  		FromPort:      0,
   254  		ToPort:        0,
   255  		IPProtocol:    "ICMP",
   256  		CIDR:          "0.0.0.0/0",
   257  	}
   258  
   259  	rule, err := secgroups.CreateRule(client.ServiceClient(), opts).Extract()
   260  	th.AssertNoErr(t, err)
   261  
   262  	expected := &secgroups.Rule{
   263  		FromPort:      0,
   264  		ToPort:        0,
   265  		Group:         secgroups.Group{},
   266  		IPProtocol:    "ICMP",
   267  		ParentGroupID: groupID,
   268  		IPRange:       secgroups.IPRange{CIDR: "0.0.0.0/0"},
   269  		ID:            ruleID,
   270  	}
   271  
   272  	th.AssertDeepEquals(t, expected, rule)
   273  }
   274  
   275  func TestDeleteRule(t *testing.T) {
   276  	th.SetupHTTP()
   277  	defer th.TeardownHTTP()
   278  
   279  	mockDeleteRuleResponse(t, ruleID)
   280  
   281  	err := secgroups.DeleteRule(client.ServiceClient(), ruleID).ExtractErr()
   282  	th.AssertNoErr(t, err)
   283  }
   284  
   285  func TestAddServer(t *testing.T) {
   286  	th.SetupHTTP()
   287  	defer th.TeardownHTTP()
   288  
   289  	mockAddServerToGroupResponse(t, serverID)
   290  
   291  	err := secgroups.AddServer(client.ServiceClient(), serverID, "test").ExtractErr()
   292  	th.AssertNoErr(t, err)
   293  }
   294  
   295  func TestRemoveServer(t *testing.T) {
   296  	th.SetupHTTP()
   297  	defer th.TeardownHTTP()
   298  
   299  	mockRemoveServerFromGroupResponse(t, serverID)
   300  
   301  	err := secgroups.RemoveServer(client.ServiceClient(), serverID, "test").ExtractErr()
   302  	th.AssertNoErr(t, err)
   303  }