func TestGet(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/v2.0/extensions/agent", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "GET") th.TestHeader(t, r, "X-Auth-Token", fake.TokenID) w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusOK) fmt.Fprintf(w, ` { "extension": { "updated": "2013-02-03T10:00:00-00:00", "name": "agent", "links": [], "namespace": "http://docs.openstack.org/ext/agent/api/v2.0", "alias": "agent", "description": "The agent management extension." } } `) }) ext, err := extensions.Get(fake.ServiceClient(), "agent").Extract() th.AssertNoErr(t, err) th.AssertEquals(t, ext.Updated, "2013-02-03T10:00:00-00:00") th.AssertEquals(t, ext.Name, "agent") th.AssertEquals(t, ext.Namespace, "http://docs.openstack.org/ext/agent/api/v2.0") th.AssertEquals(t, ext.Alias, "agent") th.AssertEquals(t, ext.Description, "The agent management extension.") }
func TestMemberListEmpty(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleImageMemberEmptyList(t) pager := members.List(fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea") t.Logf("Pager state %v", pager) count, pages := 0, 0 err := pager.EachPage(func(page pagination.Page) (bool, error) { pages++ t.Logf("Page %v", page) members, err := members.ExtractMembers(page) if err != nil { return false, err } for _, i := range members { t.Logf("%s\t%s\t%s\t%s\t\n", i.ImageID, i.MemberID, i.Status, i.Schema) count++ } return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 0, pages) th.AssertEquals(t, 0, count) }
func TestUpdate(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleUpdate(t) options := portsbinding.UpdateOpts{ UpdateOptsBuilder: ports.UpdateOpts{ Name: "new_port_name", FixedIPs: []ports.IP{ {SubnetID: "a0304c3a-4f08-4c43-88af-d796509c97d2", IPAddress: "10.0.0.3"}, }, SecurityGroups: []string{"f0ac4394-7e4a-4409-9701-ba8be283dbc3"}, }, HostID: "HOST1", VNICType: "normal", } s, err := portsbinding.Update(fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract() th.AssertNoErr(t, err) th.AssertEquals(t, s.Name, "new_port_name") th.AssertDeepEquals(t, s.FixedIPs, []ports.IP{ {SubnetID: "a0304c3a-4f08-4c43-88af-d796509c97d2", IPAddress: "10.0.0.3"}, }) th.AssertDeepEquals(t, s.SecurityGroups, []string{"f0ac4394-7e4a-4409-9701-ba8be283dbc3"}) th.AssertEquals(t, s.HostID, "HOST1") th.AssertEquals(t, s.VNICType, "normal") }
func TestListImage(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleImageListSuccessfully(t) t.Logf("Test setup %+v\n", th.Server) t.Logf("Id\tName\tOwner\tChecksum\tSizeBytes") pager := images.List(fakeclient.ServiceClient(), images.ListOpts{Limit: 1}) t.Logf("Pager state %v", pager) count, pages := 0, 0 err := pager.EachPage(func(page pagination.Page) (bool, error) { pages++ t.Logf("Page %v", page) images, err := images.ExtractImages(page) if err != nil { return false, err } for _, i := range images { t.Logf("%s\t%s\t%s\t%s\t%v\t\n", i.ID, i.Name, i.Owner, i.Checksum, i.SizeBytes) count++ } return true, nil }) th.AssertNoErr(t, err) t.Logf("--------\n%d images listed on %d pages.\n", count, pages) th.AssertEquals(t, 3, pages) th.AssertEquals(t, 3, count) }
// test the fetch function func TestFetch(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() baseurl, err := getBasePath() th.AssertNoErr(t, err) fakeURL := strings.Join([]string{baseurl, "file.yaml"}, "/") urlparsed, err := url.Parse(fakeURL) th.AssertNoErr(t, err) th.Mux.HandleFunc(urlparsed.Path, func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "GET") w.Header().Set("Content-Type", "application/jason") w.WriteHeader(http.StatusOK) fmt.Fprintf(w, "Fee-fi-fo-fum") }) client := fakeClient{BaseClient: getHTTPClient()} te := TE{ URL: "file.yaml", client: client, } err = te.Fetch() th.AssertNoErr(t, err) th.AssertEquals(t, fakeURL, te.URL) th.AssertEquals(t, "Fee-fi-fo-fum", string(te.Bin)) }
func TestUpdate(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "PUT") th.TestHeader(t, r, "X-Auth-Token", fake.TokenID) th.TestHeader(t, r, "Content-Type", "application/json") th.TestHeader(t, r, "Accept", "application/json") th.TestJSONRequest(t, r, ` { "subnet": { "name": "my_new_subnet", "dns_nameservers": ["foo"], "host_routes": [{"destination":"","nexthop": "bar"}] } } `) w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusCreated) fmt.Fprintf(w, ` { "subnet": { "name": "my_new_subnet", "enable_dhcp": true, "network_id": "db193ab3-96e3-4cb3-8fc5-05f4296d0324", "tenant_id": "26a7980765d0414dbc1fc1f88cdb7e6e", "dns_nameservers": [], "allocation_pools": [ { "start": "10.0.0.2", "end": "10.0.0.254" } ], "host_routes": [], "ip_version": 4, "gateway_ip": "10.0.0.1", "cidr": "10.0.0.0/24", "id": "08eae331-0402-425a-923c-34f7cfe39c1b" } } `) }) opts := subnets.UpdateOpts{ Name: "my_new_subnet", DNSNameservers: []string{"foo"}, HostRoutes: []subnets.HostRoute{ {NextHop: "bar"}, }, } s, err := subnets.Update(fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract() th.AssertNoErr(t, err) th.AssertEquals(t, s.Name, "my_new_subnet") th.AssertEquals(t, s.ID, "08eae331-0402-425a-923c-34f7cfe39c1b") }
func TestGet(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/v2.0/security-groups/85cc3048-abc3-43cc-89b3-377341426ac5", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "GET") th.TestHeader(t, r, "X-Auth-Token", fake.TokenID) w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusOK) fmt.Fprintf(w, ` { "security_group": { "description": "default", "id": "85cc3048-abc3-43cc-89b3-377341426ac5", "name": "default", "security_group_rules": [ { "direction": "egress", "ethertype": "IPv6", "id": "3c0e45ff-adaf-4124-b083-bf390e5482ff", "port_range_max": null, "port_range_min": null, "protocol": null, "remote_group_id": null, "remote_ip_prefix": null, "security_group_id": "85cc3048-abc3-43cc-89b3-377341426ac5", "tenant_id": "e4f50856753b4dc6afee5fa6b9b6c550" }, { "direction": "egress", "ethertype": "IPv4", "id": "93aa42e5-80db-4581-9391-3a608bd0e448", "port_range_max": null, "port_range_min": null, "protocol": null, "remote_group_id": null, "remote_ip_prefix": null, "security_group_id": "85cc3048-abc3-43cc-89b3-377341426ac5", "tenant_id": "e4f50856753b4dc6afee5fa6b9b6c550" } ], "tenant_id": "e4f50856753b4dc6afee5fa6b9b6c550" } } `) }) sg, err := groups.Get(fake.ServiceClient(), "85cc3048-abc3-43cc-89b3-377341426ac5").Extract() th.AssertNoErr(t, err) th.AssertEquals(t, "default", sg.Description) th.AssertEquals(t, "85cc3048-abc3-43cc-89b3-377341426ac5", sg.ID) th.AssertEquals(t, "default", sg.Name) th.AssertEquals(t, 2, len(sg.Rules)) th.AssertEquals(t, "e4f50856753b4dc6afee5fa6b9b6c550", sg.TenantID) }
func TestUpdate(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "PUT") th.TestHeader(t, r, "X-Auth-Token", fake.TokenID) th.TestHeader(t, r, "Content-Type", "application/json") th.TestHeader(t, r, "Accept", "application/json") th.TestJSONRequest(t, r, ` { "network": { "name": "new_network_name", "admin_state_up": false, "shared": true } } `) w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusOK) fmt.Fprintf(w, ` { "network": { "status": "ACTIVE", "subnets": [ "54d6f61d-db07-451c-9ab3-b9609b6b6f0b" ], "name": "private-network", "provider:physical_network": null, "admin_state_up": true, "tenant_id": "4fd44f30292945e481c7b8a0c8908869", "provider:network_type": "local", "shared": true, "id": "d32019d3-bc6e-4319-9c1d-6722fc136a22", "provider:segmentation_id": null } } `) }) iTrue := true options := networks.UpdateOpts{Name: "new_network_name", AdminStateUp: gophercloud.Disabled, Shared: &iTrue} res := networks.Update(fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options) n, err := provider.ExtractUpdate(res) th.AssertNoErr(t, err) th.AssertEquals(t, "", n.PhysicalNetwork) th.AssertEquals(t, "local", n.NetworkType) th.AssertEquals(t, "", n.SegmentationID) }
func TestUpdate(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/v2.0/lb/vips/4ec89087-d057-4e2c-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "PUT") th.TestHeader(t, r, "X-Auth-Token", fake.TokenID) th.TestHeader(t, r, "Content-Type", "application/json") th.TestHeader(t, r, "Accept", "application/json") th.TestJSONRequest(t, r, ` { "vip": { "connection_limit": 1000, "session_persistence": {"type": "SOURCE_IP"} } } `) w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusAccepted) fmt.Fprintf(w, ` { "vip": { "status": "PENDING_UPDATE", "protocol": "HTTP", "description": "", "admin_state_up": true, "subnet_id": "8032909d-47a1-4715-90af-5153ffe39861", "tenant_id": "83657cfcdfe44cd5920adaf26c48ceea", "connection_limit": 1000, "pool_id": "61b1f87a-7a21-4ad3-9dda-7f81d249944f", "address": "10.0.0.11", "protocol_port": 80, "port_id": "f7e6fe6a-b8b5-43a8-8215-73456b32e0f5", "id": "c987d2be-9a3c-4ac9-a046-e8716b1350e2", "name": "NewVip" } } `) }) i1000 := 1000 options := vips.UpdateOpts{ ConnLimit: &i1000, Persistence: &vips.SessionPersistence{Type: "SOURCE_IP"}, } vip, err := vips.Update(fake.ServiceClient(), "4ec89087-d057-4e2c-911f-60a3b47ee304", options).Extract() th.AssertNoErr(t, err) th.AssertEquals(t, "PENDING_UPDATE", vip.Status) th.AssertEquals(t, 1000, vip.ConnLimit) }
func TestGet(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() MockGetResponse(t) v, err := volumes.Get(client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract() th.AssertNoErr(t, err) th.AssertEquals(t, v.Name, "vol-001") th.AssertEquals(t, v.ID, "d32019d3-bc6e-4319-9c1d-6722fc136a22") }
func TestGet(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/v2.0/ports/46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "GET") th.TestHeader(t, r, "X-Auth-Token", fake.TokenID) w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusOK) fmt.Fprintf(w, ` { "port": { "status": "ACTIVE", "name": "", "admin_state_up": true, "network_id": "a87cc70a-3e15-4acf-8205-9b711a3531b7", "tenant_id": "7e02058126cc4950b75f9970368ba177", "device_owner": "network:router_interface", "mac_address": "fa:16:3e:23:fd:d7", "fixed_ips": [ { "subnet_id": "a0304c3a-4f08-4c43-88af-d796509c97d2", "ip_address": "10.0.0.1" } ], "id": "46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2", "security_groups": [], "device_id": "5e3898d7-11be-483e-9732-b2f5eccd2b2e" } } `) }) n, err := ports.Get(fake.ServiceClient(), "46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2").Extract() th.AssertNoErr(t, err) th.AssertEquals(t, n.Status, "ACTIVE") th.AssertEquals(t, n.Name, "") th.AssertEquals(t, n.AdminStateUp, true) th.AssertEquals(t, n.NetworkID, "a87cc70a-3e15-4acf-8205-9b711a3531b7") th.AssertEquals(t, n.TenantID, "7e02058126cc4950b75f9970368ba177") th.AssertEquals(t, n.DeviceOwner, "network:router_interface") th.AssertEquals(t, n.MACAddress, "fa:16:3e:23:fd:d7") th.AssertDeepEquals(t, n.FixedIPs, []ports.IP{ {SubnetID: "a0304c3a-4f08-4c43-88af-d796509c97d2", IPAddress: "10.0.0.1"}, }) th.AssertEquals(t, n.ID, "46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2") th.AssertDeepEquals(t, n.SecurityGroups, []string{}) th.AssertEquals(t, n.Status, "ACTIVE") th.AssertEquals(t, n.DeviceID, "5e3898d7-11be-483e-9732-b2f5eccd2b2e") }
// Verifies that it is possible to get the extra specifications for a share type func TestGetExtraSpecs(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() MockGetExtraSpecsResponse(t) st, err := sharetypes.GetExtraSpecs(client.ServiceClient(), "shareTypeID").Extract() th.AssertNoErr(t, err) th.AssertEquals(t, st["snapshot_support"], "True") th.AssertEquals(t, st["driver_handles_share_servers"], "True") th.AssertEquals(t, st["my_custom_extra_spec"], "False") }
func TestGet(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() MockGetResponse(t) vt, err := volumetypes.Get(client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract() th.AssertNoErr(t, err) th.AssertDeepEquals(t, vt.ExtraSpecs, map[string]interface{}{"serverNumber": "2"}) th.AssertEquals(t, vt.Name, "vol-type-001") th.AssertEquals(t, vt.ID, "d32019d3-bc6e-4319-9c1d-6722fc136a22") }
func TestCreate(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() MockCreateResponse(t) options := &volumes.CreateOpts{Size: 75} n, err := volumes.Create(client.ServiceClient(), options).Extract() th.AssertNoErr(t, err) th.AssertEquals(t, n.Size, 4) th.AssertEquals(t, n.ID, "d32019d3-bc6e-4319-9c1d-6722fc136a22") }
func TestCreate(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() MockCreateResponse(t) options := snapshots.CreateOpts{VolumeID: "1234", Name: "snapshot-001"} n, err := snapshots.Create(client.ServiceClient(), options).Extract() th.AssertNoErr(t, err) th.AssertEquals(t, n.VolumeID, "1234") th.AssertEquals(t, n.Name, "snapshot-001") th.AssertEquals(t, n.ID, "d32019d3-bc6e-4319-9c1d-6722fc136a22") }
func TestCreate(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() MockCreateResponse(t) options := &shares.CreateOpts{Size: 1, Name: "my_test_share", ShareProto: "NFS"} n, err := shares.Create(client.ServiceClient(), options).Extract() th.AssertNoErr(t, err) th.AssertEquals(t, n.Name, "my_test_share") th.AssertEquals(t, n.Size, 1) th.AssertEquals(t, n.ShareProto, "NFS") }
func TestGet(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleGetExtensionsSuccessfully(t) ext, err := extensions.Get(client.ServiceClient(), "agent").Extract() th.AssertNoErr(t, err) th.AssertEquals(t, ext.Updated, "2013-02-03T10:00:00-00:00") th.AssertEquals(t, ext.Name, "agent") th.AssertEquals(t, ext.Namespace, "http://docs.openstack.org/ext/agent/api/v2.0") th.AssertEquals(t, ext.Alias, "agent") th.AssertEquals(t, ext.Description, "The agent management extension.") }
func TestHostRoute(t *testing.T) { sejson := []byte(` {"subnet": { "name": "test-subnet", "enable_dhcp": false, "network_id": "3e66c41e-cbbd-4019-9aab-740b7e4150a0", "tenant_id": "f86e123198cf42d19c8854c5f80c2f06", "dns_nameservers": [], "gateway_ip": "172.16.0.1", "ipv6_ra_mode": null, "allocation_pools": [ { "start": "172.16.0.2", "end": "172.16.255.254" } ], "host_routes": [ { "destination": "172.20.1.0/24", "nexthop": "172.16.0.2" } ], "ip_version": 4, "ipv6_address_mode": null, "cidr": "172.16.0.0/16", "id": "6dcaa873-7115-41af-9ef5-915f73636e43", "subnetpool_id": null }} `) var dejson interface{} err := json.Unmarshal(sejson, &dejson) if err != nil { t.Fatalf("%s", err) } resp := gophercloud.Result{Body: dejson} var subnetWrapper struct { Subnet subnets.Subnet `json:"subnet"` } err = resp.ExtractInto(&subnetWrapper) if err != nil { t.Fatalf("%s", err) } route := subnetWrapper.Subnet.HostRoutes[0] th.AssertEquals(t, route.NextHop, "172.16.0.2") th.AssertEquals(t, route.DestinationCIDR, "172.20.1.0/24") }
func TestMemberUpdateSuccessfully(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() counter := HandleImageMemberUpdate(t) im, err := members.Update(fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", "8989447062e04a818baf9e073fd04fa7", members.UpdateOpts{ Status: "accepted", }).Extract() th.AssertEquals(t, 1, counter.Counter) th.AssertNoErr(t, err) createdAt, err := time.Parse(time.RFC3339, "2013-11-26T07:21:21Z") th.AssertNoErr(t, err) updatedAt, err := time.Parse(time.RFC3339, "2013-11-26T07:21:21Z") th.AssertNoErr(t, err) th.AssertDeepEquals(t, members.Member{ CreatedAt: createdAt, ImageID: "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", MemberID: "8989447062e04a818baf9e073fd04fa7", Schema: "/v2/schemas/member", Status: "accepted", UpdatedAt: updatedAt, }, *im) }
func TestListGlobalParams(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() fixture.SetupHandler(t, globalParamListURL, "GET", "", ListParamsJSON, 200) pages := 0 err := configurations.ListGlobalParams(fake.ServiceClient(), versionID).EachPage(func(page pagination.Page) (bool, error) { pages++ actual, err := configurations.ExtractParams(page) if err != nil { return false, err } expected := []configurations.Param{ {Max: 1, Min: 0, Name: "innodb_file_per_table", RestartRequired: true, Type: "integer"}, {Max: 4294967296, Min: 0, Name: "key_buffer_size", RestartRequired: false, Type: "integer"}, {Max: 65535, Min: 2, Name: "connect_timeout", RestartRequired: false, Type: "integer"}, {Max: 4294967296, Min: 0, Name: "join_buffer_size", RestartRequired: false, Type: "integer"}, } th.AssertDeepEquals(t, actual, expected) return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 1, pages) }
func TestListFlavors(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleList(t) pages := 0 err := flavors.List(fake.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) { pages++ actual, err := flavors.ExtractFlavors(page) if err != nil { return false, err } expected := []flavors.Flavor{ { ID: 1, Name: "m1.tiny", RAM: 512, Links: []gophercloud.Link{ {Href: "https://openstack.example.com/v1.0/1234/flavors/1", Rel: "self"}, {Href: "https://openstack.example.com/flavors/1", Rel: "bookmark"}, }, }, { ID: 2, Name: "m1.small", RAM: 1024, Links: []gophercloud.Link{ {Href: "https://openstack.example.com/v1.0/1234/flavors/2", Rel: "self"}, {Href: "https://openstack.example.com/flavors/2", Rel: "bookmark"}, }, }, { ID: 3, Name: "m1.medium", RAM: 2048, Links: []gophercloud.Link{ {Href: "https://openstack.example.com/v1.0/1234/flavors/3", Rel: "self"}, {Href: "https://openstack.example.com/flavors/3", Rel: "bookmark"}, }, }, { ID: 4, Name: "m1.large", RAM: 4096, Links: []gophercloud.Link{ {Href: "https://openstack.example.com/v1.0/1234/flavors/4", Rel: "self"}, {Href: "https://openstack.example.com/flavors/4", Rel: "bookmark"}, }, }, } th.AssertDeepEquals(t, expected, actual) return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 1, pages) }
func TestList(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() mockListRulesResponse(t) count := 0 err := defsecrules.List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := defsecrules.ExtractDefaultRules(page) th.AssertNoErr(t, err) expected := []defsecrules.DefaultRule{ { FromPort: 80, ID: ruleID, IPProtocol: "TCP", IPRange: secgroups.IPRange{CIDR: "10.10.10.0/24"}, ToPort: 80, }, } th.CheckDeepEquals(t, expected, actual) return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 1, count) }
func TestListInstances(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() fixture.SetupHandler(t, resURL+"/instances", "GET", "", ListInstancesJSON, 200) expectedInstance := instances.Instance{ ID: "d4603f69-ec7e-4e9b-803f-600b9205576f", Name: "json_rack_instance", } pages := 0 err := configurations.ListInstances(fake.ServiceClient(), configID).EachPage(func(page pagination.Page) (bool, error) { pages++ actual, err := instances.ExtractInstances(page) if err != nil { return false, err } th.AssertDeepEquals(t, actual, []instances.Instance{expectedInstance}) return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 1, pages) }
func TestGet(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/networks/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "GET") th.TestHeader(t, r, "X-Auth-Token", fake.TokenID) w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusOK) fmt.Fprintf(w, ` { "network": { "admin_state_up": true, "id": "8d05a1b1-297a-46ca-8974-17debf51ca3c", "name": "ext_net", "router:external": true, "shared": false, "status": "ACTIVE", "subnets": [ "2f1fb918-9b0e-4bf9-9a50-6cebbb4db2c5" ], "tenant_id": "5eb8995cf717462c9df8d1edfa498010" } } `) }) res := networks.Get(fake.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22") n, err := external.ExtractGet(res) th.AssertNoErr(t, err) th.AssertEquals(t, true, n.External) }
// Verifies that share networks list can be called with query parameters func TestPaginatedListDetail(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() MockFilteredListResponse(t) options := &sharenetworks.ListOpts{ Offset: 0, Limit: 1, } count := 0 err := sharenetworks.ListDetail(client.ServiceClient(), options).EachPage(func(page pagination.Page) (bool, error) { count++ _, err := sharenetworks.ExtractShareNetworks(page) if err != nil { t.Errorf("Failed to extract share networks: %v", err) return false, err } return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, count, 3) }
func TestListByServer(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() mockListGroupsByServerResponse(t, serverID) count := 0 err := secgroups.ListByServer(client.ServiceClient(), serverID).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := secgroups.ExtractSecurityGroups(page) if err != nil { t.Errorf("Failed to extract users: %v", err) return false, err } expected := []secgroups.SecurityGroup{ { ID: groupID, Description: "default", Name: "default", Rules: []secgroups.Rule{}, TenantID: "openstack", }, } th.CheckDeepEquals(t, expected, actual) return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 1, count) }
func TestRole(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() MockListRoleResponse(t) count := 0 err := roles.List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := roles.ExtractRoles(page) if err != nil { t.Errorf("Failed to extract users: %v", err) return false, err } expected := []roles.Role{ { ID: "123", Name: "compute:admin", Description: "Nova Administrator", }, } th.CheckDeepEquals(t, expected, actual) return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 1, count) }
func TestEnumerateMarker(t *testing.T) { pager := createMarkerPaged(t) defer testhelper.TeardownHTTP() callCount := 0 err := pager.EachPage(func(page pagination.Page) (bool, error) { actual, err := ExtractMarkerStrings(page) if err != nil { return false, err } t.Logf("Handler invoked with %v", actual) var expected []string switch callCount { case 0: expected = []string{"aaa", "bbb", "ccc"} case 1: expected = []string{"ddd", "eee", "fff"} case 2: expected = []string{"ggg", "hhh", "iii"} default: t.Fatalf("Unexpected call count: %d", callCount) return false, nil } testhelper.CheckDeepEquals(t, expected, actual) callCount++ return true, nil }) testhelper.AssertNoErr(t, err) testhelper.AssertEquals(t, callCount, 3) }
func TestListVersions(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() MockListResponse(t) count := 0 apiversions.List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := apiversions.ExtractAPIVersions(page) th.AssertNoErr(t, err) expected := []apiversions.APIVersion{ { ID: "v1.0", Status: "CURRENT", Updated: "2012-01-04T11:33:21Z", }, { ID: "v2.0", Status: "CURRENT", Updated: "2012-11-21T11:33:21Z", }, } th.AssertDeepEquals(t, expected, actual) return true, nil }) th.AssertEquals(t, 1, count) }
func TestListAllContainers(t *testing.T) { // Create a new client to execute the HTTP requests. See common.go for newClient body. client := newClient(t) numContainers := 20 // Create a slice of random container names. cNames := make([]string, numContainers) for i := 0; i < numContainers; i++ { cNames[i] = tools.RandomString("gophercloud-test-container-", 8) } // Create numContainers containers. for i := 0; i < len(cNames); i++ { res := containers.Create(client, cNames[i], nil) th.AssertNoErr(t, res.Err) } // Delete the numContainers containers after function completion. defer func() { for i := 0; i < len(cNames); i++ { res := containers.Delete(client, cNames[i]) th.AssertNoErr(t, res.Err) } }() // List all the numContainer names that were just created. To just list those, // the 'prefix' parameter is used. allPages, err := containers.List(client, &containers.ListOpts{Full: true, Limit: 5, Prefix: "gophercloud-test-container-"}).AllPages() th.AssertNoErr(t, err) containerInfoList, err := containers.ExtractInfo(allPages) th.AssertNoErr(t, err) for _, n := range containerInfoList { t.Logf("Container: Name [%s] Count [%d] Bytes [%d]", n.Name, n.Count, n.Bytes) } th.AssertEquals(t, numContainers, len(containerInfoList)) // List the info for all the numContainer containers that were created. allPages, err = containers.List(client, &containers.ListOpts{Full: false, Limit: 2, Prefix: "gophercloud-test-container-"}).AllPages() th.AssertNoErr(t, err) containerNamesList, err := containers.ExtractNames(allPages) th.AssertNoErr(t, err) for _, n := range containerNamesList { t.Logf("Container: Name [%s]", n) } th.AssertEquals(t, numContainers, len(containerNamesList)) }