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

     1  //go:build acceptance
     2  // +build acceptance
     3  
     4  package v3
     5  
     6  import (
     7  	"testing"
     8  
     9  	golangsdk "github.com/opentelekomcloud/gophertelekomcloud"
    10  	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/clients"
    11  	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/tools"
    12  	"github.com/opentelekomcloud/gophertelekomcloud/openstack/identity/v3/domains"
    13  	"github.com/opentelekomcloud/gophertelekomcloud/openstack/identity/v3/roles"
    14  	th "github.com/opentelekomcloud/gophertelekomcloud/testhelper"
    15  )
    16  
    17  func TestRolesList(t *testing.T) {
    18  	client, err := clients.NewIdentityV3Client()
    19  	th.AssertNoErr(t, err)
    20  
    21  	listOpts := roles.ListOpts{
    22  		DomainID: "default",
    23  	}
    24  
    25  	allPages, err := roles.List(client, listOpts).AllPages()
    26  	th.AssertNoErr(t, err)
    27  
    28  	allRoles, err := roles.ExtractRoles(allPages)
    29  	th.AssertNoErr(t, err)
    30  
    31  	for _, role := range allRoles {
    32  		tools.PrintResource(t, role)
    33  	}
    34  }
    35  
    36  func TestRolesGet(t *testing.T) {
    37  	client, err := clients.NewIdentityV3Client()
    38  	th.AssertNoErr(t, err)
    39  
    40  	role, err := FindRole(t, client)
    41  	th.AssertNoErr(t, err)
    42  
    43  	p, err := roles.Get(client, role.ID).Extract()
    44  	th.AssertNoErr(t, err)
    45  
    46  	tools.PrintResource(t, p)
    47  }
    48  
    49  func TestRoleCRUD(t *testing.T) {
    50  	client, err := clients.NewIdentityV3Client()
    51  	th.AssertNoErr(t, err)
    52  
    53  	createOpts := roles.CreateOpts{
    54  		Name:     "testrole",
    55  		DomainID: "default",
    56  		Extra: map[string]interface{}{
    57  			"description": "test role description",
    58  		},
    59  	}
    60  
    61  	// Create Role in the default domain
    62  	role, err := CreateRole(t, client, &createOpts)
    63  	th.AssertNoErr(t, err)
    64  
    65  	t.Cleanup(func() {
    66  		DeleteRole(t, client, role.ID)
    67  	})
    68  
    69  	tools.PrintResource(t, role)
    70  	tools.PrintResource(t, role.Extra)
    71  
    72  	updateOpts := roles.UpdateOpts{
    73  		Extra: map[string]interface{}{
    74  			"description": "updated test role description",
    75  		},
    76  	}
    77  
    78  	newRole, err := roles.Update(client, role.ID, updateOpts).Extract()
    79  	th.AssertNoErr(t, err)
    80  
    81  	tools.PrintResource(t, newRole)
    82  	tools.PrintResource(t, newRole.Extra)
    83  }
    84  
    85  func TestRoleAssignToUserOnProject(t *testing.T) {
    86  	client, err := clients.NewIdentityV3Client()
    87  	th.AssertNoErr(t, err)
    88  
    89  	project, err := CreateProject(t, client, nil)
    90  	if err != nil {
    91  		t.Fatal("Unable to create a project")
    92  	}
    93  	t.Cleanup(func() {
    94  		DeleteProject(t, client, project.ID)
    95  	})
    96  
    97  	role, err := FindRole(t, client)
    98  	th.AssertNoErr(t, err)
    99  
   100  	user, err := CreateUser(t, client, nil)
   101  	th.AssertNoErr(t, err)
   102  	t.Cleanup(func() {
   103  		DeleteUser(t, client, user.ID)
   104  	})
   105  
   106  	t.Logf("Attempting to assign a role %s to a user %s on a project %s", role.Name, user.Name, project.Name)
   107  	err = roles.Assign(client, role.ID, roles.AssignOpts{
   108  		UserID:    user.ID,
   109  		ProjectID: project.ID,
   110  	}).ExtractErr()
   111  	th.AssertNoErr(t, err)
   112  
   113  	t.Logf("Successfully assigned a role %s to a user %s on a project %s", role.Name, user.Name, project.Name)
   114  	t.Cleanup(func() {
   115  		UnassignRole(t, client, role.ID, &roles.UnassignOpts{
   116  			UserID:    user.ID,
   117  			ProjectID: project.ID,
   118  		})
   119  	})
   120  
   121  	allPages, err := roles.ListAssignments(client, roles.ListAssignmentsOpts{
   122  		ScopeProjectID: project.ID,
   123  		UserID:         user.ID,
   124  	}).AllPages()
   125  	th.AssertNoErr(t, err)
   126  
   127  	allRoleAssignments, err := roles.ExtractRoleAssignments(allPages)
   128  	th.AssertNoErr(t, err)
   129  
   130  	t.Logf("Role assignments of user %s on project %s:", user.Name, project.Name)
   131  	for _, roleAssignment := range allRoleAssignments {
   132  		tools.PrintResource(t, roleAssignment)
   133  	}
   134  }
   135  
   136  func TestRoleAssignToUserOnDomain(t *testing.T) {
   137  	client, err := clients.NewIdentityV3Client()
   138  	th.AssertNoErr(t, err)
   139  
   140  	domain, err := CreateDomain(t, client, &domains.CreateOpts{
   141  		Enabled: golangsdk.Disabled,
   142  	})
   143  	th.AssertNoErr(t, err)
   144  
   145  	t.Cleanup(func() {
   146  		DeleteDomain(t, client, domain.ID)
   147  	})
   148  
   149  	role, err := FindRole(t, client)
   150  	th.AssertNoErr(t, err)
   151  
   152  	user, err := CreateUser(t, client, nil)
   153  	th.AssertNoErr(t, err)
   154  
   155  	t.Cleanup(func() {
   156  		DeleteUser(t, client, user.ID)
   157  	})
   158  
   159  	t.Logf("Attempting to assign a role %s to a user %s on a domain %s", role.Name, user.Name, domain.Name)
   160  	err = roles.Assign(client, role.ID, roles.AssignOpts{
   161  		UserID:   user.ID,
   162  		DomainID: domain.ID,
   163  	}).ExtractErr()
   164  	th.AssertNoErr(t, err)
   165  
   166  	t.Logf("Successfully assigned a role %s to a user %s on a domain %s", role.Name, user.Name, domain.Name)
   167  	t.Cleanup(func() {
   168  		UnassignRole(t, client, role.ID, &roles.UnassignOpts{
   169  			UserID:   user.ID,
   170  			DomainID: domain.ID,
   171  		})
   172  	})
   173  
   174  	allPages, err := roles.ListAssignments(client, roles.ListAssignmentsOpts{
   175  		ScopeDomainID: domain.ID,
   176  		UserID:        user.ID,
   177  	}).AllPages()
   178  	th.AssertNoErr(t, err)
   179  
   180  	allRoleAssignments, err := roles.ExtractRoleAssignments(allPages)
   181  	th.AssertNoErr(t, err)
   182  
   183  	t.Logf("Role assignments of user %s on domain %s:", user.Name, domain.Name)
   184  	for _, roleAssignment := range allRoleAssignments {
   185  		tools.PrintResource(t, roleAssignment)
   186  	}
   187  }
   188  
   189  func TestRoleAssignToGroupOnDomain(t *testing.T) {
   190  	client, err := clients.NewIdentityV3Client()
   191  	th.AssertNoErr(t, err)
   192  
   193  	domain, err := CreateDomain(t, client, &domains.CreateOpts{
   194  		Enabled: golangsdk.Disabled,
   195  	})
   196  	th.AssertNoErr(t, err)
   197  
   198  	t.Cleanup(func() {
   199  		DeleteDomain(t, client, domain.ID)
   200  	})
   201  
   202  	role, err := FindRole(t, client)
   203  	th.AssertNoErr(t, err)
   204  
   205  	group, err := CreateGroup(t, client, nil)
   206  	th.AssertNoErr(t, err)
   207  
   208  	t.Cleanup(func() {
   209  		DeleteGroup(t, client, group.ID)
   210  	})
   211  
   212  	t.Logf("Attempting to assign a role %s to a group %s on a domain %s", role.Name, group.Name, domain.Name)
   213  	err = roles.Assign(client, role.ID, roles.AssignOpts{
   214  		GroupID:  group.ID,
   215  		DomainID: domain.ID,
   216  	}).ExtractErr()
   217  	th.AssertNoErr(t, err)
   218  
   219  	t.Logf("Successfully assigned a role %s to a group %s on a domain %s", role.Name, group.Name, domain.Name)
   220  	t.Cleanup(func() {
   221  		UnassignRole(t, client, role.ID, &roles.UnassignOpts{
   222  			GroupID:  group.ID,
   223  			DomainID: domain.ID,
   224  		})
   225  	})
   226  
   227  	allPages, err := roles.ListAssignments(client, roles.ListAssignmentsOpts{
   228  		GroupID:       group.ID,
   229  		ScopeDomainID: domain.ID,
   230  	}).AllPages()
   231  	th.AssertNoErr(t, err)
   232  
   233  	allRoleAssignments, err := roles.ExtractRoleAssignments(allPages)
   234  	th.AssertNoErr(t, err)
   235  
   236  	t.Logf("Role assignments of group %s on domain %s:", group.Name, domain.Name)
   237  	for _, roleAssignment := range allRoleAssignments {
   238  		tools.PrintResource(t, roleAssignment)
   239  	}
   240  }
   241  
   242  func TestRoleAssignToGroupOnProject(t *testing.T) {
   243  	client, err := clients.NewIdentityV3Client()
   244  	th.AssertNoErr(t, err)
   245  
   246  	project, err := CreateProject(t, client, nil)
   247  	th.AssertNoErr(t, err)
   248  
   249  	t.Cleanup(func() {
   250  		DeleteProject(t, client, project.ID)
   251  	})
   252  
   253  	role, err := FindRole(t, client)
   254  	th.AssertNoErr(t, err)
   255  
   256  	group, err := CreateGroup(t, client, nil)
   257  	th.AssertNoErr(t, err)
   258  	t.Cleanup(func() {
   259  		DeleteGroup(t, client, group.ID)
   260  	})
   261  
   262  	t.Logf("Attempting to assign a role %s to a group %s on a project %s", role.Name, group.Name, project.Name)
   263  	err = roles.Assign(client, role.ID, roles.AssignOpts{
   264  		GroupID:   group.ID,
   265  		ProjectID: project.ID,
   266  	}).ExtractErr()
   267  	th.AssertNoErr(t, err)
   268  	t.Logf("Successfully assigned a role %s to a group %s on a project %s", role.Name, group.Name, project.Name)
   269  
   270  	t.Cleanup(func() {
   271  		UnassignRole(t, client, role.ID, &roles.UnassignOpts{
   272  			GroupID:   group.ID,
   273  			ProjectID: project.ID,
   274  		})
   275  	})
   276  
   277  	allPages, err := roles.ListAssignments(client, roles.ListAssignmentsOpts{
   278  		GroupID:        group.ID,
   279  		ScopeProjectID: project.ID,
   280  	}).AllPages()
   281  	th.AssertNoErr(t, err)
   282  
   283  	allRoleAssignments, err := roles.ExtractRoleAssignments(allPages)
   284  	th.AssertNoErr(t, err)
   285  
   286  	t.Logf("Role assignments of group %s on project %s:", group.Name, project.Name)
   287  	for _, roleAssignment := range allRoleAssignments {
   288  		tools.PrintResource(t, roleAssignment)
   289  	}
   290  }