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

     1  package testing
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/gophercloud/gophercloud/openstack/identity/v3/roles"
     7  	"github.com/gophercloud/gophercloud/pagination"
     8  	th "github.com/gophercloud/gophercloud/testhelper"
     9  	"github.com/gophercloud/gophercloud/testhelper/client"
    10  )
    11  
    12  func TestListRoles(t *testing.T) {
    13  	th.SetupHTTP()
    14  	defer th.TeardownHTTP()
    15  	HandleListRolesSuccessfully(t)
    16  
    17  	count := 0
    18  	err := roles.List(client.ServiceClient(), nil).EachPage(func(page pagination.Page) (bool, error) {
    19  		count++
    20  
    21  		actual, err := roles.ExtractRoles(page)
    22  		th.AssertNoErr(t, err)
    23  
    24  		th.CheckDeepEquals(t, ExpectedRolesSlice, actual)
    25  
    26  		return true, nil
    27  	})
    28  	th.AssertNoErr(t, err)
    29  	th.CheckEquals(t, count, 1)
    30  }
    31  
    32  func TestListRolesAllPages(t *testing.T) {
    33  	th.SetupHTTP()
    34  	defer th.TeardownHTTP()
    35  	HandleListRolesSuccessfully(t)
    36  
    37  	allPages, err := roles.List(client.ServiceClient(), nil).AllPages()
    38  	th.AssertNoErr(t, err)
    39  	actual, err := roles.ExtractRoles(allPages)
    40  	th.AssertNoErr(t, err)
    41  	th.CheckDeepEquals(t, ExpectedRolesSlice, actual)
    42  	th.AssertEquals(t, ExpectedRolesSlice[1].Extra["description"], "read-only support role")
    43  }
    44  
    45  func TestListUsersFiltersCheck(t *testing.T) {
    46  	type test struct {
    47  		filterName string
    48  		wantErr    bool
    49  	}
    50  	tests := []test{
    51  		{"foo__contains", false},
    52  		{"foo", true},
    53  		{"foo_contains", true},
    54  		{"foo__", true},
    55  		{"__foo", true},
    56  	}
    57  
    58  	var listOpts roles.ListOpts
    59  	for _, _test := range tests {
    60  		listOpts.Filters = map[string]string{_test.filterName: "bar"}
    61  		_, err := listOpts.ToRoleListQuery()
    62  
    63  		if !_test.wantErr {
    64  			th.AssertNoErr(t, err)
    65  		} else {
    66  			switch _t := err.(type) {
    67  			case nil:
    68  				t.Fatal("error expected but got a nil")
    69  			case roles.InvalidListFilter:
    70  			default:
    71  				t.Fatalf("unexpected error type: [%T]", _t)
    72  			}
    73  		}
    74  	}
    75  }
    76  
    77  func TestGetRole(t *testing.T) {
    78  	th.SetupHTTP()
    79  	defer th.TeardownHTTP()
    80  	HandleGetRoleSuccessfully(t)
    81  
    82  	actual, err := roles.Get(client.ServiceClient(), "9fe1d3").Extract()
    83  
    84  	th.AssertNoErr(t, err)
    85  	th.CheckDeepEquals(t, SecondRole, *actual)
    86  }
    87  
    88  func TestCreateRole(t *testing.T) {
    89  	th.SetupHTTP()
    90  	defer th.TeardownHTTP()
    91  	HandleCreateRoleSuccessfully(t)
    92  
    93  	createOpts := roles.CreateOpts{
    94  		Name:     "support",
    95  		DomainID: "1789d1",
    96  		Extra: map[string]interface{}{
    97  			"description": "read-only support role",
    98  		},
    99  	}
   100  
   101  	actual, err := roles.Create(client.ServiceClient(), createOpts).Extract()
   102  	th.AssertNoErr(t, err)
   103  	th.CheckDeepEquals(t, SecondRole, *actual)
   104  }
   105  
   106  func TestUpdateRole(t *testing.T) {
   107  	th.SetupHTTP()
   108  	defer th.TeardownHTTP()
   109  	HandleUpdateRoleSuccessfully(t)
   110  
   111  	updateOpts := roles.UpdateOpts{
   112  		Extra: map[string]interface{}{
   113  			"description": "admin read-only support role",
   114  		},
   115  	}
   116  
   117  	actual, err := roles.Update(client.ServiceClient(), "9fe1d3", updateOpts).Extract()
   118  	th.AssertNoErr(t, err)
   119  	th.CheckDeepEquals(t, SecondRoleUpdated, *actual)
   120  }
   121  
   122  func TestDeleteRole(t *testing.T) {
   123  	th.SetupHTTP()
   124  	defer th.TeardownHTTP()
   125  	HandleDeleteRoleSuccessfully(t)
   126  
   127  	res := roles.Delete(client.ServiceClient(), "9fe1d3")
   128  	th.AssertNoErr(t, res.Err)
   129  }
   130  
   131  func TestListAssignmentsSinglePage(t *testing.T) {
   132  	th.SetupHTTP()
   133  	defer th.TeardownHTTP()
   134  	HandleListRoleAssignmentsSuccessfully(t)
   135  
   136  	count := 0
   137  	err := roles.ListAssignments(client.ServiceClient(), roles.ListAssignmentsOpts{}).EachPage(func(page pagination.Page) (bool, error) {
   138  		count++
   139  		actual, err := roles.ExtractRoleAssignments(page)
   140  		th.AssertNoErr(t, err)
   141  
   142  		th.CheckDeepEquals(t, ExpectedRoleAssignmentsSlice, actual)
   143  
   144  		return true, nil
   145  	})
   146  	th.AssertNoErr(t, err)
   147  	th.CheckEquals(t, count, 1)
   148  }
   149  
   150  func TestListAssignmentsWithNamesSinglePage(t *testing.T) {
   151  	th.SetupHTTP()
   152  	defer th.TeardownHTTP()
   153  	HandleListRoleAssignmentsWithNamesSuccessfully(t)
   154  
   155  	var includeNames = true
   156  	listOpts := roles.ListAssignmentsOpts{
   157  		IncludeNames: &includeNames,
   158  	}
   159  
   160  	count := 0
   161  	err := roles.ListAssignments(client.ServiceClient(), listOpts).EachPage(func(page pagination.Page) (bool, error) {
   162  		count++
   163  		actual, err := roles.ExtractRoleAssignments(page)
   164  		th.AssertNoErr(t, err)
   165  
   166  		th.CheckDeepEquals(t, ExpectedRoleAssignmentsWithNamesSlice, actual)
   167  
   168  		return true, nil
   169  	})
   170  	th.AssertNoErr(t, err)
   171  	th.CheckEquals(t, count, 1)
   172  }
   173  
   174  func TestListAssignmentsWithSubtreeSinglePage(t *testing.T) {
   175  	th.SetupHTTP()
   176  	defer th.TeardownHTTP()
   177  	HandleListRoleAssignmentsWithSubtreeSuccessfully(t)
   178  
   179  	var includeSubtree = true
   180  	listOpts := roles.ListAssignmentsOpts{
   181  		IncludeSubtree: &includeSubtree,
   182  	}
   183  
   184  	count := 0
   185  	err := roles.ListAssignments(client.ServiceClient(), listOpts).EachPage(func(page pagination.Page) (bool, error) {
   186  		count++
   187  		actual, err := roles.ExtractRoleAssignments(page)
   188  		th.AssertNoErr(t, err)
   189  
   190  		th.CheckDeepEquals(t, ExpectedRoleAssignmentsSlice, actual)
   191  
   192  		return true, nil
   193  	})
   194  	th.AssertNoErr(t, err)
   195  	th.CheckEquals(t, count, 1)
   196  }
   197  
   198  func TestListAssignmentsOnResource_ProjectsUsers(t *testing.T) {
   199  	th.SetupHTTP()
   200  	defer th.TeardownHTTP()
   201  	HandleListAssignmentsOnResourceSuccessfully_ProjectsUsers(t)
   202  
   203  	count := 0
   204  	err := roles.ListAssignmentsOnResource(client.ServiceClient(), roles.ListAssignmentsOnResourceOpts{
   205  		UserID:    "{user_id}",
   206  		ProjectID: "{project_id}",
   207  	}).EachPage(func(page pagination.Page) (bool, error) {
   208  		count++
   209  
   210  		actual, err := roles.ExtractRoles(page)
   211  		th.AssertNoErr(t, err)
   212  		th.CheckDeepEquals(t, ExpectedRolesOnResourceSlice, actual)
   213  
   214  		return true, nil
   215  	})
   216  	th.AssertNoErr(t, err)
   217  	th.CheckEquals(t, count, 1)
   218  }
   219  
   220  func TestListAssignmentsOnResource_DomainsUsers(t *testing.T) {
   221  	th.SetupHTTP()
   222  	defer th.TeardownHTTP()
   223  	HandleListAssignmentsOnResourceSuccessfully_DomainsUsers(t)
   224  
   225  	count := 0
   226  	err := roles.ListAssignmentsOnResource(client.ServiceClient(), roles.ListAssignmentsOnResourceOpts{
   227  		UserID:   "{user_id}",
   228  		DomainID: "{domain_id}",
   229  	}).EachPage(func(page pagination.Page) (bool, error) {
   230  		count++
   231  
   232  		actual, err := roles.ExtractRoles(page)
   233  		th.AssertNoErr(t, err)
   234  		th.CheckDeepEquals(t, ExpectedRolesOnResourceSlice, actual)
   235  
   236  		return true, nil
   237  	})
   238  	th.AssertNoErr(t, err)
   239  	th.CheckEquals(t, count, 1)
   240  }
   241  
   242  func TestListAssignmentsOnResource_ProjectsGroups(t *testing.T) {
   243  	th.SetupHTTP()
   244  	defer th.TeardownHTTP()
   245  	HandleListAssignmentsOnResourceSuccessfully_ProjectsGroups(t)
   246  
   247  	count := 0
   248  	err := roles.ListAssignmentsOnResource(client.ServiceClient(), roles.ListAssignmentsOnResourceOpts{
   249  		GroupID:   "{group_id}",
   250  		ProjectID: "{project_id}",
   251  	}).EachPage(func(page pagination.Page) (bool, error) {
   252  		count++
   253  
   254  		actual, err := roles.ExtractRoles(page)
   255  		th.AssertNoErr(t, err)
   256  		th.CheckDeepEquals(t, ExpectedRolesOnResourceSlice, actual)
   257  
   258  		return true, nil
   259  	})
   260  	th.AssertNoErr(t, err)
   261  	th.CheckEquals(t, count, 1)
   262  }
   263  
   264  func TestListAssignmentsOnResource_DomainsGroups(t *testing.T) {
   265  	th.SetupHTTP()
   266  	defer th.TeardownHTTP()
   267  	HandleListAssignmentsOnResourceSuccessfully_DomainsGroups(t)
   268  
   269  	count := 0
   270  	err := roles.ListAssignmentsOnResource(client.ServiceClient(), roles.ListAssignmentsOnResourceOpts{
   271  		GroupID:  "{group_id}",
   272  		DomainID: "{domain_id}",
   273  	}).EachPage(func(page pagination.Page) (bool, error) {
   274  		count++
   275  
   276  		actual, err := roles.ExtractRoles(page)
   277  		th.AssertNoErr(t, err)
   278  		th.CheckDeepEquals(t, ExpectedRolesOnResourceSlice, actual)
   279  
   280  		return true, nil
   281  	})
   282  	th.AssertNoErr(t, err)
   283  	th.CheckEquals(t, count, 1)
   284  }
   285  
   286  func TestAssign(t *testing.T) {
   287  	th.SetupHTTP()
   288  	defer th.TeardownHTTP()
   289  	HandleAssignSuccessfully(t)
   290  
   291  	err := roles.Assign(client.ServiceClient(), "{role_id}", roles.AssignOpts{
   292  		UserID:    "{user_id}",
   293  		ProjectID: "{project_id}",
   294  	}).ExtractErr()
   295  	th.AssertNoErr(t, err)
   296  
   297  	err = roles.Assign(client.ServiceClient(), "{role_id}", roles.AssignOpts{
   298  		UserID:   "{user_id}",
   299  		DomainID: "{domain_id}",
   300  	}).ExtractErr()
   301  	th.AssertNoErr(t, err)
   302  
   303  	err = roles.Assign(client.ServiceClient(), "{role_id}", roles.AssignOpts{
   304  		GroupID:   "{group_id}",
   305  		ProjectID: "{project_id}",
   306  	}).ExtractErr()
   307  	th.AssertNoErr(t, err)
   308  
   309  	err = roles.Assign(client.ServiceClient(), "{role_id}", roles.AssignOpts{
   310  		GroupID:  "{group_id}",
   311  		DomainID: "{domain_id}",
   312  	}).ExtractErr()
   313  	th.AssertNoErr(t, err)
   314  }
   315  
   316  func TestUnassign(t *testing.T) {
   317  	th.SetupHTTP()
   318  	defer th.TeardownHTTP()
   319  	HandleUnassignSuccessfully(t)
   320  
   321  	err := roles.Unassign(client.ServiceClient(), "{role_id}", roles.UnassignOpts{
   322  		UserID:    "{user_id}",
   323  		ProjectID: "{project_id}",
   324  	}).ExtractErr()
   325  	th.AssertNoErr(t, err)
   326  
   327  	err = roles.Unassign(client.ServiceClient(), "{role_id}", roles.UnassignOpts{
   328  		UserID:   "{user_id}",
   329  		DomainID: "{domain_id}",
   330  	}).ExtractErr()
   331  	th.AssertNoErr(t, err)
   332  
   333  	err = roles.Unassign(client.ServiceClient(), "{role_id}", roles.UnassignOpts{
   334  		GroupID:   "{group_id}",
   335  		ProjectID: "{project_id}",
   336  	}).ExtractErr()
   337  	th.AssertNoErr(t, err)
   338  
   339  	err = roles.Unassign(client.ServiceClient(), "{role_id}", roles.UnassignOpts{
   340  		GroupID:  "{group_id}",
   341  		DomainID: "{domain_id}",
   342  	}).ExtractErr()
   343  	th.AssertNoErr(t, err)
   344  }