github.com/gophercloud/gophercloud@v1.11.0/internal/acceptance/openstack/identity/v3/projects_test.go (about)

     1  //go:build acceptance
     2  // +build acceptance
     3  
     4  package v3
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/gophercloud/gophercloud/internal/acceptance/clients"
    10  	"github.com/gophercloud/gophercloud/internal/acceptance/tools"
    11  	"github.com/gophercloud/gophercloud/openstack/identity/v3/projects"
    12  	th "github.com/gophercloud/gophercloud/testhelper"
    13  )
    14  
    15  func TestProjectsListAvailable(t *testing.T) {
    16  	clients.RequireNonAdmin(t)
    17  
    18  	client, err := clients.NewIdentityV3Client()
    19  	th.AssertNoErr(t, err)
    20  
    21  	allPages, err := projects.ListAvailable(client).AllPages()
    22  	th.AssertNoErr(t, err)
    23  
    24  	allProjects, err := projects.ExtractProjects(allPages)
    25  	th.AssertNoErr(t, err)
    26  
    27  	for _, project := range allProjects {
    28  		tools.PrintResource(t, project)
    29  	}
    30  }
    31  
    32  func TestProjectsList(t *testing.T) {
    33  	clients.RequireAdmin(t)
    34  
    35  	client, err := clients.NewIdentityV3Client()
    36  	th.AssertNoErr(t, err)
    37  
    38  	var iTrue bool = true
    39  	listOpts := projects.ListOpts{
    40  		Enabled: &iTrue,
    41  	}
    42  
    43  	allPages, err := projects.List(client, listOpts).AllPages()
    44  	th.AssertNoErr(t, err)
    45  
    46  	allProjects, err := projects.ExtractProjects(allPages)
    47  	th.AssertNoErr(t, err)
    48  
    49  	var found bool
    50  	for _, project := range allProjects {
    51  		tools.PrintResource(t, project)
    52  
    53  		if project.Name == "admin" {
    54  			found = true
    55  		}
    56  	}
    57  
    58  	th.AssertEquals(t, found, true)
    59  
    60  	listOpts.Filters = map[string]string{
    61  		"name__contains": "dmi",
    62  	}
    63  
    64  	allPages, err = projects.List(client, listOpts).AllPages()
    65  	th.AssertNoErr(t, err)
    66  
    67  	allProjects, err = projects.ExtractProjects(allPages)
    68  	th.AssertNoErr(t, err)
    69  
    70  	found = false
    71  	for _, project := range allProjects {
    72  		tools.PrintResource(t, project)
    73  
    74  		if project.Name == "admin" {
    75  			found = true
    76  		}
    77  	}
    78  
    79  	th.AssertEquals(t, found, true)
    80  
    81  	listOpts.Filters = map[string]string{
    82  		"name__contains": "foo",
    83  	}
    84  
    85  	allPages, err = projects.List(client, listOpts).AllPages()
    86  	th.AssertNoErr(t, err)
    87  
    88  	allProjects, err = projects.ExtractProjects(allPages)
    89  	th.AssertNoErr(t, err)
    90  
    91  	found = false
    92  	for _, project := range allProjects {
    93  		tools.PrintResource(t, project)
    94  
    95  		if project.Name == "admin" {
    96  			found = true
    97  		}
    98  	}
    99  
   100  	th.AssertEquals(t, found, false)
   101  }
   102  
   103  func TestProjectsGet(t *testing.T) {
   104  	clients.RequireAdmin(t)
   105  
   106  	client, err := clients.NewIdentityV3Client()
   107  	th.AssertNoErr(t, err)
   108  
   109  	allPages, err := projects.List(client, nil).AllPages()
   110  	th.AssertNoErr(t, err)
   111  
   112  	allProjects, err := projects.ExtractProjects(allPages)
   113  	th.AssertNoErr(t, err)
   114  
   115  	project := allProjects[0]
   116  	p, err := projects.Get(client, project.ID).Extract()
   117  	if err != nil {
   118  		t.Fatalf("Unable to get project: %v", err)
   119  	}
   120  
   121  	tools.PrintResource(t, p)
   122  
   123  	th.AssertEquals(t, project.Name, p.Name)
   124  }
   125  
   126  func TestProjectsCRUD(t *testing.T) {
   127  	clients.RequireAdmin(t)
   128  
   129  	client, err := clients.NewIdentityV3Client()
   130  	th.AssertNoErr(t, err)
   131  
   132  	project, err := CreateProject(t, client, nil)
   133  	th.AssertNoErr(t, err)
   134  	defer DeleteProject(t, client, project.ID)
   135  
   136  	tools.PrintResource(t, project)
   137  
   138  	description := ""
   139  	iFalse := false
   140  	updateOpts := projects.UpdateOpts{
   141  		Description: &description,
   142  		Enabled:     &iFalse,
   143  	}
   144  
   145  	updatedProject, err := projects.Update(client, project.ID, updateOpts).Extract()
   146  	th.AssertNoErr(t, err)
   147  
   148  	tools.PrintResource(t, updatedProject)
   149  	th.AssertEquals(t, updatedProject.Description, description)
   150  	th.AssertEquals(t, updatedProject.Enabled, iFalse)
   151  }
   152  
   153  func TestProjectsDomain(t *testing.T) {
   154  	clients.RequireAdmin(t)
   155  
   156  	client, err := clients.NewIdentityV3Client()
   157  	th.AssertNoErr(t, err)
   158  
   159  	var iTrue = true
   160  	createOpts := projects.CreateOpts{
   161  		IsDomain: &iTrue,
   162  	}
   163  
   164  	projectDomain, err := CreateProject(t, client, &createOpts)
   165  	th.AssertNoErr(t, err)
   166  	defer DeleteProject(t, client, projectDomain.ID)
   167  
   168  	tools.PrintResource(t, projectDomain)
   169  
   170  	createOpts = projects.CreateOpts{
   171  		DomainID: projectDomain.ID,
   172  	}
   173  
   174  	project, err := CreateProject(t, client, &createOpts)
   175  	th.AssertNoErr(t, err)
   176  	defer DeleteProject(t, client, project.ID)
   177  
   178  	tools.PrintResource(t, project)
   179  
   180  	th.AssertEquals(t, project.DomainID, projectDomain.ID)
   181  
   182  	var iFalse = false
   183  	updateOpts := projects.UpdateOpts{
   184  		Enabled: &iFalse,
   185  	}
   186  
   187  	_, err = projects.Update(client, projectDomain.ID, updateOpts).Extract()
   188  	th.AssertNoErr(t, err)
   189  }
   190  
   191  func TestProjectsNested(t *testing.T) {
   192  	clients.RequireAdmin(t)
   193  
   194  	client, err := clients.NewIdentityV3Client()
   195  	th.AssertNoErr(t, err)
   196  
   197  	projectMain, err := CreateProject(t, client, nil)
   198  	th.AssertNoErr(t, err)
   199  	defer DeleteProject(t, client, projectMain.ID)
   200  
   201  	tools.PrintResource(t, projectMain)
   202  
   203  	createOpts := projects.CreateOpts{
   204  		ParentID: projectMain.ID,
   205  	}
   206  
   207  	project, err := CreateProject(t, client, &createOpts)
   208  	th.AssertNoErr(t, err)
   209  	defer DeleteProject(t, client, project.ID)
   210  
   211  	tools.PrintResource(t, project)
   212  
   213  	th.AssertEquals(t, project.ParentID, projectMain.ID)
   214  }
   215  
   216  func TestProjectsTags(t *testing.T) {
   217  	clients.RequireAdmin(t)
   218  
   219  	client, err := clients.NewIdentityV3Client()
   220  	th.AssertNoErr(t, err)
   221  
   222  	createOpts := projects.CreateOpts{
   223  		Tags: []string{"Tag1", "Tag2"},
   224  	}
   225  
   226  	projectMain, err := CreateProject(t, client, &createOpts)
   227  	th.AssertNoErr(t, err)
   228  	defer DeleteProject(t, client, projectMain.ID)
   229  
   230  	// Search using all tags
   231  	listOpts := projects.ListOpts{
   232  		Tags: "Tag1,Tag2",
   233  	}
   234  
   235  	allPages, err := projects.List(client, listOpts).AllPages()
   236  	th.AssertNoErr(t, err)
   237  
   238  	allProjects, err := projects.ExtractProjects(allPages)
   239  	th.AssertNoErr(t, err)
   240  
   241  	found := false
   242  	for _, project := range allProjects {
   243  		tools.PrintResource(t, project)
   244  
   245  		if project.Name == projectMain.Name {
   246  			found = true
   247  		}
   248  	}
   249  
   250  	th.AssertEquals(t, found, true)
   251  
   252  	// Search using all tags, including a not existing one
   253  	listOpts = projects.ListOpts{
   254  		Tags: "Tag1,Tag2,Tag3",
   255  	}
   256  
   257  	allPages, err = projects.List(client, listOpts).AllPages()
   258  	th.AssertNoErr(t, err)
   259  
   260  	allProjects, err = projects.ExtractProjects(allPages)
   261  	th.AssertNoErr(t, err)
   262  
   263  	th.AssertEquals(t, len(allProjects), 0)
   264  
   265  	// Search matching at least one tag
   266  	listOpts = projects.ListOpts{
   267  		TagsAny: "Tag1,Tag2,Tag3",
   268  	}
   269  
   270  	allPages, err = projects.List(client, listOpts).AllPages()
   271  	th.AssertNoErr(t, err)
   272  
   273  	allProjects, err = projects.ExtractProjects(allPages)
   274  	th.AssertNoErr(t, err)
   275  
   276  	found = false
   277  	for _, project := range allProjects {
   278  		tools.PrintResource(t, project)
   279  
   280  		if project.Name == projectMain.Name {
   281  			found = true
   282  		}
   283  	}
   284  
   285  	th.AssertEquals(t, found, true)
   286  
   287  	// Search not matching any single tag
   288  	listOpts = projects.ListOpts{
   289  		NotTagsAny: "Tag1",
   290  	}
   291  
   292  	allPages, err = projects.List(client, listOpts).AllPages()
   293  	th.AssertNoErr(t, err)
   294  
   295  	allProjects, err = projects.ExtractProjects(allPages)
   296  	th.AssertNoErr(t, err)
   297  
   298  	found = false
   299  	for _, project := range allProjects {
   300  		tools.PrintResource(t, project)
   301  
   302  		if project.Name == projectMain.Name {
   303  			found = true
   304  		}
   305  	}
   306  
   307  	th.AssertEquals(t, found, false)
   308  
   309  	// Search matching not all tags
   310  	listOpts = projects.ListOpts{
   311  		NotTags: "Tag1,Tag2,Tag3",
   312  	}
   313  
   314  	allPages, err = projects.List(client, listOpts).AllPages()
   315  	th.AssertNoErr(t, err)
   316  
   317  	allProjects, err = projects.ExtractProjects(allPages)
   318  	th.AssertNoErr(t, err)
   319  
   320  	found = false
   321  	for _, project := range allProjects {
   322  		tools.PrintResource(t, project)
   323  
   324  		if project.Name == "admin" {
   325  			found = true
   326  		}
   327  	}
   328  
   329  	th.AssertEquals(t, found, true)
   330  
   331  	// Update the tags
   332  	updateOpts := projects.UpdateOpts{
   333  		Tags: &[]string{"Tag1"},
   334  	}
   335  
   336  	updatedProject, err := projects.Update(client, projectMain.ID, updateOpts).Extract()
   337  	th.AssertNoErr(t, err)
   338  
   339  	tools.PrintResource(t, updatedProject)
   340  	th.AssertEquals(t, len(updatedProject.Tags), 1)
   341  	th.AssertEquals(t, updatedProject.Tags[0], "Tag1")
   342  
   343  	// Update the project, but not its tags
   344  	description := "Test description"
   345  	updateOpts = projects.UpdateOpts{
   346  		Description: &description,
   347  	}
   348  
   349  	updatedProject, err = projects.Update(client, projectMain.ID, updateOpts).Extract()
   350  	th.AssertNoErr(t, err)
   351  
   352  	tools.PrintResource(t, updatedProject)
   353  	th.AssertEquals(t, len(updatedProject.Tags), 1)
   354  	th.AssertEquals(t, updatedProject.Tags[0], "Tag1")
   355  
   356  	// Remove all Tags
   357  	updateOpts = projects.UpdateOpts{
   358  		Tags: &[]string{},
   359  	}
   360  
   361  	updatedProject, err = projects.Update(client, projectMain.ID, updateOpts).Extract()
   362  	th.AssertNoErr(t, err)
   363  
   364  	tools.PrintResource(t, updatedProject)
   365  	th.AssertEquals(t, len(updatedProject.Tags), 0)
   366  }