1package v3 2 3import ( 4 "testing" 5 6 "github.com/gophercloud/gophercloud" 7 "github.com/gophercloud/gophercloud/acceptance/tools" 8 "github.com/gophercloud/gophercloud/openstack/identity/v3/domains" 9 "github.com/gophercloud/gophercloud/openstack/identity/v3/extensions/trusts" 10 "github.com/gophercloud/gophercloud/openstack/identity/v3/groups" 11 "github.com/gophercloud/gophercloud/openstack/identity/v3/projects" 12 "github.com/gophercloud/gophercloud/openstack/identity/v3/regions" 13 "github.com/gophercloud/gophercloud/openstack/identity/v3/roles" 14 "github.com/gophercloud/gophercloud/openstack/identity/v3/services" 15 "github.com/gophercloud/gophercloud/openstack/identity/v3/users" 16 th "github.com/gophercloud/gophercloud/testhelper" 17) 18 19// CreateProject will create a project with a random name. 20// It takes an optional createOpts parameter since creating a project 21// has so many options. An error will be returned if the project was 22// unable to be created. 23func CreateProject(t *testing.T, client *gophercloud.ServiceClient, c *projects.CreateOpts) (*projects.Project, error) { 24 name := tools.RandomString("ACPTTEST", 8) 25 description := tools.RandomString("ACPTTEST-DESC", 8) 26 t.Logf("Attempting to create project: %s", name) 27 28 var createOpts projects.CreateOpts 29 if c != nil { 30 createOpts = *c 31 } else { 32 createOpts = projects.CreateOpts{} 33 } 34 35 createOpts.Name = name 36 createOpts.Description = description 37 38 project, err := projects.Create(client, createOpts).Extract() 39 if err != nil { 40 return project, err 41 } 42 43 t.Logf("Successfully created project %s with ID %s", name, project.ID) 44 45 th.AssertEquals(t, project.Name, name) 46 th.AssertEquals(t, project.Description, description) 47 48 return project, nil 49} 50 51// CreateUser will create a user with a random name. 52// It takes an optional createOpts parameter since creating a user 53// has so many options. An error will be returned if the user was 54// unable to be created. 55func CreateUser(t *testing.T, client *gophercloud.ServiceClient, c *users.CreateOpts) (*users.User, error) { 56 name := tools.RandomString("ACPTTEST", 8) 57 t.Logf("Attempting to create user: %s", name) 58 59 var createOpts users.CreateOpts 60 if c != nil { 61 createOpts = *c 62 } else { 63 createOpts = users.CreateOpts{} 64 } 65 66 createOpts.Name = name 67 68 user, err := users.Create(client, createOpts).Extract() 69 if err != nil { 70 return user, err 71 } 72 73 t.Logf("Successfully created user %s with ID %s", name, user.ID) 74 75 th.AssertEquals(t, user.Name, name) 76 77 return user, nil 78} 79 80// CreateGroup will create a group with a random name. 81// It takes an optional createOpts parameter since creating a group 82// has so many options. An error will be returned if the group was 83// unable to be created. 84func CreateGroup(t *testing.T, client *gophercloud.ServiceClient, c *groups.CreateOpts) (*groups.Group, error) { 85 name := tools.RandomString("ACPTTEST", 8) 86 t.Logf("Attempting to create group: %s", name) 87 88 var createOpts groups.CreateOpts 89 if c != nil { 90 createOpts = *c 91 } else { 92 createOpts = groups.CreateOpts{} 93 } 94 95 createOpts.Name = name 96 97 group, err := groups.Create(client, createOpts).Extract() 98 if err != nil { 99 return group, err 100 } 101 102 t.Logf("Successfully created group %s with ID %s", name, group.ID) 103 104 th.AssertEquals(t, group.Name, name) 105 106 return group, nil 107} 108 109// CreateDomain will create a domain with a random name. 110// It takes an optional createOpts parameter since creating a domain 111// has many options. An error will be returned if the domain was 112// unable to be created. 113func CreateDomain(t *testing.T, client *gophercloud.ServiceClient, c *domains.CreateOpts) (*domains.Domain, error) { 114 name := tools.RandomString("ACPTTEST", 8) 115 t.Logf("Attempting to create domain: %s", name) 116 117 var createOpts domains.CreateOpts 118 if c != nil { 119 createOpts = *c 120 } else { 121 createOpts = domains.CreateOpts{} 122 } 123 124 createOpts.Name = name 125 126 domain, err := domains.Create(client, createOpts).Extract() 127 if err != nil { 128 return domain, err 129 } 130 131 t.Logf("Successfully created domain %s with ID %s", name, domain.ID) 132 133 th.AssertEquals(t, domain.Name, name) 134 135 return domain, nil 136} 137 138// CreateRole will create a role with a random name. 139// It takes an optional createOpts parameter since creating a role 140// has so many options. An error will be returned if the role was 141// unable to be created. 142func CreateRole(t *testing.T, client *gophercloud.ServiceClient, c *roles.CreateOpts) (*roles.Role, error) { 143 name := tools.RandomString("ACPTTEST", 8) 144 t.Logf("Attempting to create role: %s", name) 145 146 var createOpts roles.CreateOpts 147 if c != nil { 148 createOpts = *c 149 } else { 150 createOpts = roles.CreateOpts{} 151 } 152 153 createOpts.Name = name 154 155 role, err := roles.Create(client, createOpts).Extract() 156 if err != nil { 157 return role, err 158 } 159 160 t.Logf("Successfully created role %s with ID %s", name, role.ID) 161 162 th.AssertEquals(t, role.Name, name) 163 164 return role, nil 165} 166 167// CreateRegion will create a region with a random name. 168// It takes an optional createOpts parameter since creating a region 169// has so many options. An error will be returned if the region was 170// unable to be created. 171func CreateRegion(t *testing.T, client *gophercloud.ServiceClient, c *regions.CreateOpts) (*regions.Region, error) { 172 id := tools.RandomString("ACPTTEST", 8) 173 t.Logf("Attempting to create region: %s", id) 174 175 var createOpts regions.CreateOpts 176 if c != nil { 177 createOpts = *c 178 } else { 179 createOpts = regions.CreateOpts{} 180 } 181 182 createOpts.ID = id 183 184 region, err := regions.Create(client, createOpts).Extract() 185 if err != nil { 186 return region, err 187 } 188 189 t.Logf("Successfully created region %s", id) 190 191 th.AssertEquals(t, region.ID, id) 192 193 return region, nil 194} 195 196// CreateService will create a service with a random name. 197// It takes an optional createOpts parameter since creating a service 198// has so many options. An error will be returned if the service was 199// unable to be created. 200func CreateService(t *testing.T, client *gophercloud.ServiceClient, c *services.CreateOpts) (*services.Service, error) { 201 name := tools.RandomString("ACPTTEST", 8) 202 t.Logf("Attempting to create service: %s", name) 203 204 var createOpts services.CreateOpts 205 if c != nil { 206 createOpts = *c 207 } else { 208 createOpts = services.CreateOpts{} 209 } 210 211 createOpts.Extra["name"] = name 212 213 service, err := services.Create(client, createOpts).Extract() 214 if err != nil { 215 return service, err 216 } 217 218 t.Logf("Successfully created service %s", service.ID) 219 220 th.AssertEquals(t, service.Extra["name"], name) 221 222 return service, nil 223} 224 225// DeleteProject will delete a project by ID. A fatal error will occur if 226// the project ID failed to be deleted. This works best when using it as 227// a deferred function. 228func DeleteProject(t *testing.T, client *gophercloud.ServiceClient, projectID string) { 229 err := projects.Delete(client, projectID).ExtractErr() 230 if err != nil { 231 t.Fatalf("Unable to delete project %s: %v", projectID, err) 232 } 233 234 t.Logf("Deleted project: %s", projectID) 235} 236 237// DeleteUser will delete a user by ID. A fatal error will occur if 238// the user failed to be deleted. This works best when using it as 239// a deferred function. 240func DeleteUser(t *testing.T, client *gophercloud.ServiceClient, userID string) { 241 err := users.Delete(client, userID).ExtractErr() 242 if err != nil { 243 t.Fatalf("Unable to delete user with ID %s: %v", userID, err) 244 } 245 246 t.Logf("Deleted user with ID: %s", userID) 247} 248 249// DeleteGroup will delete a group by ID. A fatal error will occur if 250// the group failed to be deleted. This works best when using it as 251// a deferred function. 252func DeleteGroup(t *testing.T, client *gophercloud.ServiceClient, groupID string) { 253 err := groups.Delete(client, groupID).ExtractErr() 254 if err != nil { 255 t.Fatalf("Unable to delete group %s: %v", groupID, err) 256 } 257 258 t.Logf("Deleted group: %s", groupID) 259} 260 261// DeleteDomain will delete a domain by ID. A fatal error will occur if 262// the project ID failed to be deleted. This works best when using it as 263// a deferred function. 264func DeleteDomain(t *testing.T, client *gophercloud.ServiceClient, domainID string) { 265 err := domains.Delete(client, domainID).ExtractErr() 266 if err != nil { 267 t.Fatalf("Unable to delete domain %s: %v", domainID, err) 268 } 269 270 t.Logf("Deleted domain: %s", domainID) 271} 272 273// DeleteRole will delete a role by ID. A fatal error will occur if 274// the role failed to be deleted. This works best when using it as 275// a deferred function. 276func DeleteRole(t *testing.T, client *gophercloud.ServiceClient, roleID string) { 277 err := roles.Delete(client, roleID).ExtractErr() 278 if err != nil { 279 t.Fatalf("Unable to delete role %s: %v", roleID, err) 280 } 281 282 t.Logf("Deleted role: %s", roleID) 283} 284 285// DeleteRegion will delete a reg by ID. A fatal error will occur if 286// the region failed to be deleted. This works best when using it as 287// a deferred function. 288func DeleteRegion(t *testing.T, client *gophercloud.ServiceClient, regionID string) { 289 err := regions.Delete(client, regionID).ExtractErr() 290 if err != nil { 291 t.Fatalf("Unable to delete region %s: %v", regionID, err) 292 } 293 294 t.Logf("Deleted region: %s", regionID) 295} 296 297// DeleteService will delete a reg by ID. A fatal error will occur if 298// the service failed to be deleted. This works best when using it as 299// a deferred function. 300func DeleteService(t *testing.T, client *gophercloud.ServiceClient, serviceID string) { 301 err := services.Delete(client, serviceID).ExtractErr() 302 if err != nil { 303 t.Fatalf("Unable to delete service %s: %v", serviceID, err) 304 } 305 306 t.Logf("Deleted service: %s", serviceID) 307} 308 309// UnassignRole will delete a role assigned to a user/group on a project/domain 310// A fatal error will occur if it fails to delete the assignment. 311// This works best when using it as a deferred function. 312func UnassignRole(t *testing.T, client *gophercloud.ServiceClient, roleID string, opts *roles.UnassignOpts) { 313 err := roles.Unassign(client, roleID, *opts).ExtractErr() 314 if err != nil { 315 t.Fatalf("Unable to unassign a role %v on context %+v: %v", roleID, *opts, err) 316 } 317 t.Logf("Unassigned the role %v on context %+v", roleID, *opts) 318} 319 320// FindRole finds all roles that the current authenticated client has access 321// to and returns the first one found. An error will be returned if the lookup 322// was unsuccessful. 323func FindRole(t *testing.T, client *gophercloud.ServiceClient) (*roles.Role, error) { 324 t.Log("Attempting to find a role") 325 var role *roles.Role 326 327 allPages, err := roles.List(client, nil).AllPages() 328 if err != nil { 329 return nil, err 330 } 331 332 allRoles, err := roles.ExtractRoles(allPages) 333 if err != nil { 334 return nil, err 335 } 336 337 for _, r := range allRoles { 338 role = &r 339 break 340 } 341 342 t.Logf("Successfully found a role %s with ID %s", role.Name, role.ID) 343 344 return role, nil 345} 346 347// CreateTrust will create a trust with the provided options. 348// An error will be returned if the trust was unable to be created. 349func CreateTrust(t *testing.T, client *gophercloud.ServiceClient, createOpts trusts.CreateOpts) (*trusts.Trust, error) { 350 trust, err := trusts.Create(client, createOpts).Extract() 351 if err != nil { 352 return nil, err 353 } 354 355 t.Logf("Successfully created trust %s", trust.ID) 356 357 return trust, nil 358} 359 360// DeleteTrust will delete a trust by ID. A fatal error will occur if 361// the trust failed to be deleted. This works best when using it as 362// a deferred function. 363func DeleteTrust(t *testing.T, client *gophercloud.ServiceClient, trustID string) { 364 err := trusts.Delete(client, trustID).ExtractErr() 365 if err != nil { 366 t.Fatalf("Unable to delete trust %s: %v", trustID, err) 367 } 368 369 t.Logf("Deleted trust: %s", trustID) 370} 371 372// FindTrust finds all trusts that the current authenticated client has access 373// to and returns the first one found. An error will be returned if the lookup 374// was unsuccessful. 375func FindTrust(t *testing.T, client *gophercloud.ServiceClient) (*trusts.Trust, error) { 376 t.Log("Attempting to find a trust") 377 var trust *trusts.Trust 378 379 allPages, err := trusts.List(client, nil).AllPages() 380 if err != nil { 381 return nil, err 382 } 383 384 allTrusts, err := trusts.ExtractTrusts(allPages) 385 if err != nil { 386 return nil, err 387 } 388 389 for _, t := range allTrusts { 390 trust = &t 391 break 392 } 393 394 t.Logf("Successfully found a trust %s ", trust.ID) 395 396 return trust, nil 397} 398