github.com/gophercloud/gophercloud@v1.11.0/openstack/identity/v3/extensions/federation/testing/requests_test.go (about)

     1  package testing
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/gophercloud/gophercloud/openstack/identity/v3/extensions/federation"
     7  	"github.com/gophercloud/gophercloud/pagination"
     8  	th "github.com/gophercloud/gophercloud/testhelper"
     9  	"github.com/gophercloud/gophercloud/testhelper/client"
    10  )
    11  
    12  func TestListMappings(t *testing.T) {
    13  	th.SetupHTTP()
    14  	defer th.TeardownHTTP()
    15  	HandleListMappingsSuccessfully(t)
    16  
    17  	count := 0
    18  	err := federation.ListMappings(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
    19  		count++
    20  
    21  		actual, err := federation.ExtractMappings(page)
    22  		th.AssertNoErr(t, err)
    23  
    24  		th.CheckDeepEquals(t, ExpectedMappingsSlice, actual)
    25  
    26  		return true, nil
    27  	})
    28  	th.AssertNoErr(t, err)
    29  	th.CheckEquals(t, count, 1)
    30  }
    31  
    32  func TestListMappingsAllPages(t *testing.T) {
    33  	th.SetupHTTP()
    34  	defer th.TeardownHTTP()
    35  	HandleListMappingsSuccessfully(t)
    36  
    37  	allPages, err := federation.ListMappings(client.ServiceClient()).AllPages()
    38  	th.AssertNoErr(t, err)
    39  	actual, err := federation.ExtractMappings(allPages)
    40  	th.AssertNoErr(t, err)
    41  	th.CheckDeepEquals(t, ExpectedMappingsSlice, actual)
    42  }
    43  
    44  func TestCreateMappings(t *testing.T) {
    45  	th.SetupHTTP()
    46  	defer th.TeardownHTTP()
    47  	HandleCreateMappingSuccessfully(t)
    48  
    49  	createOpts := federation.CreateMappingOpts{
    50  		Rules: []federation.MappingRule{
    51  			{
    52  				Local: []federation.RuleLocal{
    53  					{
    54  						User: &federation.RuleUser{
    55  							Name: "{0}",
    56  						},
    57  					},
    58  					{
    59  						Group: &federation.Group{
    60  							ID: "0cd5e9",
    61  						},
    62  					},
    63  				},
    64  				Remote: []federation.RuleRemote{
    65  					{
    66  						Type: "UserName",
    67  					},
    68  					{
    69  						Type: "orgPersonType",
    70  						NotAnyOf: []string{
    71  							"Contractor",
    72  							"Guest",
    73  						},
    74  					},
    75  				},
    76  			},
    77  		},
    78  	}
    79  
    80  	actual, err := federation.CreateMapping(client.ServiceClient(), "ACME", createOpts).Extract()
    81  	th.AssertNoErr(t, err)
    82  	th.CheckDeepEquals(t, MappingACME, *actual)
    83  }
    84  
    85  func TestGetMapping(t *testing.T) {
    86  	th.SetupHTTP()
    87  	defer th.TeardownHTTP()
    88  	HandleGetMappingSuccessfully(t)
    89  
    90  	actual, err := federation.GetMapping(client.ServiceClient(), "ACME").Extract()
    91  	th.AssertNoErr(t, err)
    92  	th.CheckDeepEquals(t, MappingACME, *actual)
    93  }
    94  
    95  func TestUpdateMapping(t *testing.T) {
    96  	th.SetupHTTP()
    97  	defer th.TeardownHTTP()
    98  	HandleUpdateMappingSuccessfully(t)
    99  
   100  	updateOpts := federation.UpdateMappingOpts{
   101  		Rules: []federation.MappingRule{
   102  			{
   103  				Local: []federation.RuleLocal{
   104  					{
   105  						User: &federation.RuleUser{
   106  							Name: "{0}",
   107  						},
   108  					},
   109  					{
   110  						Group: &federation.Group{
   111  							ID: "0cd5e9",
   112  						},
   113  					},
   114  				},
   115  				Remote: []federation.RuleRemote{
   116  					{
   117  						Type: "UserName",
   118  					},
   119  					{
   120  						Type: "orgPersonType",
   121  						AnyOneOf: []string{
   122  							"Contractor",
   123  							"SubContractor",
   124  						},
   125  					},
   126  				},
   127  			},
   128  		},
   129  	}
   130  
   131  	actual, err := federation.UpdateMapping(client.ServiceClient(), "ACME", updateOpts).Extract()
   132  	th.AssertNoErr(t, err)
   133  	th.CheckDeepEquals(t, MappingUpdated, *actual)
   134  }
   135  
   136  func TestDeleteMapping(t *testing.T) {
   137  	th.SetupHTTP()
   138  	defer th.TeardownHTTP()
   139  	HandleDeleteMappingSuccessfully(t)
   140  
   141  	res := federation.DeleteMapping(client.ServiceClient(), "ACME")
   142  	th.AssertNoErr(t, res.Err)
   143  }