func TestUpdate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleUpdate(t)
options := 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 := 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 TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleGet(t)
n, err := 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.DeviceID, "5e3898d7-11be-483e-9732-b2f5eccd2b2e")
th.AssertEquals(t, n.HostID, "devstack")
th.AssertEquals(t, n.VNICType, "normal")
th.AssertEquals(t, n.VIFType, "ovs")
th.AssertDeepEquals(t, n.VIFDetails, map[string]interface{}{"port_filter": true, "ovs_hybrid_plug": true})
}
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",
"binding:host_id": "HOST1",
"binding:vnic_type": "normal"
}
}
`)
})
n, err := 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, []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.DeviceID, "5e3898d7-11be-483e-9732-b2f5eccd2b2e")
th.AssertEquals(t, n.HostID, "HOST1")
th.AssertEquals(t, n.VNICType, "normal")
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/subnets/54d6f61d-db07-451c-9ab3-b9609b6b6f0b", 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, `
{
"subnet": {
"name": "my_subnet",
"enable_dhcp": true,
"network_id": "d32019d3-bc6e-4319-9c1d-6722fc136a22",
"tenant_id": "4fd44f30292945e481c7b8a0c8908869",
"dns_nameservers": [],
"allocation_pools": [
{
"start": "192.0.0.2",
"end": "192.255.255.254"
}
],
"host_routes": [],
"ip_version": 4,
"gateway_ip": "192.0.0.1",
"cidr": "192.0.0.0/8",
"id": "54d6f61d-db07-451c-9ab3-b9609b6b6f0b"
}
}
`)
})
s, err := Get(fake.ServiceClient(), "54d6f61d-db07-451c-9ab3-b9609b6b6f0b").Extract()
th.AssertNoErr(t, err)
th.AssertEquals(t, s.Name, "my_subnet")
th.AssertEquals(t, s.EnableDHCP, true)
th.AssertEquals(t, s.NetworkID, "d32019d3-bc6e-4319-9c1d-6722fc136a22")
th.AssertEquals(t, s.TenantID, "4fd44f30292945e481c7b8a0c8908869")
th.AssertDeepEquals(t, s.DNSNameservers, []string{})
th.AssertDeepEquals(t, s.AllocationPools, []os.AllocationPool{
os.AllocationPool{
Start: "192.0.0.2",
End: "192.255.255.254",
},
})
th.AssertDeepEquals(t, s.HostRoutes, []os.HostRoute{})
th.AssertEquals(t, s.IPVersion, 4)
th.AssertEquals(t, s.GatewayIP, "192.0.0.1")
th.AssertEquals(t, s.CIDR, "192.0.0.0/8")
th.AssertEquals(t, s.ID, "54d6f61d-db07-451c-9ab3-b9609b6b6f0b")
}
func TestListGlobalParams(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, globalParamListURL, "GET", "", ListParamsJSON, 200)
pages := 0
err := ListGlobalParams(fake.ServiceClient(), versionID).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := ExtractParams(page)
if err != nil {
return false, err
}
expected := []Param{
Param{Max: 1, Min: 0, Name: "innodb_file_per_table", RestartRequired: true, Type: "integer"},
Param{Max: 4294967296, Min: 0, Name: "key_buffer_size", RestartRequired: false, Type: "integer"},
Param{Max: 65535, Min: 2, Name: "connect_timeout", RestartRequired: false, Type: "integer"},
Param{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 TestGetStats(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockGetStatsResponse(t, id1)
content, err := GetStats(client.ServiceClient(), id1).Extract()
th.AssertNoErr(t, err)
expected := &Stats{
ConnectTimeout: 10,
ConnectError: 20,
ConnectFailure: 30,
DataTimedOut: 40,
KeepAliveTimedOut: 50,
MaxConnections: 60,
CurrentConnections: 40,
SSLConnectTimeout: 10,
SSLConnectError: 20,
SSLConnectFailure: 30,
SSLDataTimedOut: 40,
SSLKeepAliveTimedOut: 50,
SSLMaxConnections: 60,
SSLCurrentConnections: 40,
}
th.AssertDeepEquals(t, expected, content)
}
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 := 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 TestShowMemberDetails(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleImageMemberDetails(t)
md, err := Get(fakeclient.ServiceClient(),
"da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
"8989447062e04a818baf9e073fd04fa7").Extract()
th.AssertNoErr(t, err)
th.AssertNotNil(t, md)
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, ImageMember{
CreatedAt: createdAt,
ImageID: "da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
MemberID: "8989447062e04a818baf9e073fd04fa7",
Schema: "/v2/schemas/member",
Status: "pending",
UpdatedAt: updatedAt,
}, *md)
}
func TestCreate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, _rootURL, "POST", createReq, createResp, 200)
opts := CreateOpts{
Name: "json_rack_instance",
FlavorRef: "1",
Databases: osDBs.BatchCreateOpts{
osDBs.CreateOpts{CharSet: "utf8", Collate: "utf8_general_ci", Name: "sampledb"},
osDBs.CreateOpts{Name: "nextround"},
},
Users: osUsers.BatchCreateOpts{
osUsers.CreateOpts{
Name: "demouser",
Password: "******",
Databases: osDBs.BatchCreateOpts{
osDBs.CreateOpts{Name: "sampledb"},
},
},
},
Size: 2,
RestorePoint: "1234567890",
}
instance, err := Create(fake.ServiceClient(), opts).Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expectedInstance, instance)
}
func TestGetCloudNetwork(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/cloud_networks/07426958-1ebf-4c38-b032-d456820ca21a", func(w http.ResponseWriter, r *http.Request) {
th.TestMethod(t, r, "GET")
th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
th.TestHeader(t, r, "Accept", "application/json")
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
fmt.Fprintf(w, `{
"cidr": "192.168.100.0/24",
"created": "2014-05-25T01:23:42Z",
"id": "07426958-1ebf-4c38-b032-d456820ca21a",
"name": "RC-CLOUD",
"updated": "2014-05-25T02:28:44Z"
}`)
})
expected := &CloudNetwork{
CIDR: "192.168.100.0/24",
CreatedAt: time.Date(2014, 5, 25, 1, 23, 42, 0, time.UTC),
ID: "07426958-1ebf-4c38-b032-d456820ca21a",
Name: "RC-CLOUD",
UpdatedAt: time.Date(2014, 5, 25, 2, 28, 44, 0, time.UTC),
}
actual, err := Get(fake.ServiceClient(), "07426958-1ebf-4c38-b032-d456820ca21a").Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected, actual)
}
func TestAddRuleICMPZero(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockAddRuleResponseICMPZero(t)
opts := CreateRuleOpts{
ParentGroupID: groupID,
FromPort: 0,
ToPort: 0,
IPProtocol: "ICMP",
CIDR: "0.0.0.0/0",
}
rule, err := CreateRule(client.ServiceClient(), opts).Extract()
th.AssertNoErr(t, err)
expected := &Rule{
FromPort: 0,
ToPort: 0,
Group: Group{},
IPProtocol: "ICMP",
ParentGroupID: groupID,
IPRange: IPRange{CIDR: "0.0.0.0/0"},
ID: ruleID,
}
th.AssertDeepEquals(t, expected, rule)
}
func TestListBackups(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL+"/backups", "GET", "", listBackupsResp, 200)
pages := 0
err := ListBackups(fake.ServiceClient(), instanceID).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := backups.ExtractBackups(page)
th.AssertNoErr(t, err)
expected := []backups.Backup{
backups.Backup{
Created: timeVal,
Description: "Backup from Restored Instance",
ID: "87972694-4be2-40f5-83f8-501656e0032a",
InstanceID: "29af2cd9-0674-48ab-b87a-b160f00208e6",
LocationRef: "http://localhost/path/to/backup",
Name: "restored_backup",
ParentID: "",
Size: 0.141026,
Status: "COMPLETED",
Updated: timeVal,
Datastore: datastores.DatastorePartial{Version: "5.1", Type: "MySQL", VersionID: "20000000-0000-0000-0000-000000000002"},
},
}
th.AssertDeepEquals(t, expected, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, pages)
}
func TestGetReplica(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL, "GET", "", getReplicaResp, 200)
replica, err := Get(fake.ServiceClient(), instanceID).Extract()
th.AssertNoErr(t, err)
expectedReplica := &Instance{
Status: "ACTIVE",
Updated: timeVal,
Name: "t1_ALT_GUEST",
Created: timeVal,
IP: []string{
"10.0.0.2",
},
Replicas: []Instance{
Instance{ID: "3c691f06-bf9a-4618-b7ec-2817ce0cf254"},
},
ID: "8b499b45-52d6-402d-b398-f9d8f279c69a",
Volume: os.Volume{
Used: 0.54,
Size: 1,
},
Flavor: flavors.Flavor{ID: "9"},
Datastore: datastores.DatastorePartial{
Version: "5.6",
Type: "mysql",
},
}
th.AssertDeepEquals(t, replica, expectedReplica)
}
func TestCreateHandleFlags(t *testing.T) {
app := cli.NewApp()
flagset := flag.NewFlagSet("flags", 1)
flagset.String("metadata", "", "")
flagset.String("container-read", "", "")
flagset.String("container-write", "", "")
flagset.Set("metadata", "key=val,foo=bar")
c := cli.NewContext(app, flagset, nil)
cmd := &commandCreate{
Ctx: &handler.Context{
CLIContext: c,
},
}
expected := &handler.Resource{
Params: ¶msCreate{
opts: containers.CreateOpts{
Metadata: map[string]string{
"key": "val",
"foo": "bar",
},
},
},
}
actual := &handler.Resource{}
err := cmd.HandleFlags(actual)
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected.Params.(*paramsCreate).opts, actual.Params.(*paramsCreate).opts)
}
func TestListFlavors(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleList(t)
pages := 0
err := List(fake.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := ExtractFlavors(page)
if err != nil {
return false, err
}
expected := []Flavor{
Flavor{
ID: "1",
Name: "m1.tiny",
RAM: 512,
Links: []gophercloud.Link{
gophercloud.Link{Href: "https://openstack.example.com/v1.0/1234/flavors/1", Rel: "self"},
gophercloud.Link{Href: "https://openstack.example.com/flavors/1", Rel: "bookmark"},
},
},
Flavor{
ID: "2",
Name: "m1.small",
RAM: 1024,
Links: []gophercloud.Link{
gophercloud.Link{Href: "https://openstack.example.com/v1.0/1234/flavors/2", Rel: "self"},
gophercloud.Link{Href: "https://openstack.example.com/flavors/2", Rel: "bookmark"},
},
},
Flavor{
ID: "3",
Name: "m1.medium",
RAM: 2048,
Links: []gophercloud.Link{
gophercloud.Link{Href: "https://openstack.example.com/v1.0/1234/flavors/3", Rel: "self"},
gophercloud.Link{Href: "https://openstack.example.com/flavors/3", Rel: "bookmark"},
},
},
Flavor{
ID: "4",
Name: "m1.large",
RAM: 4096,
Links: []gophercloud.Link{
gophercloud.Link{Href: "https://openstack.example.com/v1.0/1234/flavors/4", Rel: "self"},
gophercloud.Link{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 TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
fixture.SetupHandler(t, resURL, "GET", "", getResp, 200)
instance, err := Get(fake.ServiceClient(), backupID).Extract()
th.AssertNoErr(t, err)
expected := &Backup{
Created: timeVal,
Description: "My Backup",
ID: "61f12fef-edb1-4561-8122-e7c00ef26a82",
InstanceID: "d4603f69-ec7e-4e9b-803f-600b9205576f",
LocationRef: "",
Name: "snapshot",
ParentID: "",
Size: 100,
Status: "NEW",
Updated: timeVal,
Datastore: datastores.DatastorePartial{
Version: "5.1",
Type: "MySQL",
VersionID: "20000000-0000-0000-0000-000000000002",
},
}
th.AssertDeepEquals(t, expected, instance)
}
func TestMemberUpdateSuccessfully(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
counter := HandleImageMemberUpdate(t)
im, err := Update(fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
"8989447062e04a818baf9e073fd04fa7",
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, ImageMember{
CreatedAt: createdAt,
ImageID: "da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
MemberID: "8989447062e04a818baf9e073fd04fa7",
Schema: "/v2/schemas/member",
Status: "accepted",
UpdatedAt: updatedAt,
}, *im)
}
func TestCreateMemberSuccessfully(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleCreateImageMemberSuccessfully(t)
im, err := Create(fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
"8989447062e04a818baf9e073fd04fa7").Extract()
th.AssertNoErr(t, err)
createdAt, err := time.Parse(time.RFC3339, createdAtString)
th.AssertNoErr(t, err)
updatedAt, err := time.Parse(time.RFC3339, updatedAtString)
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, ImageMember{
CreatedAt: createdAt,
ImageID: "da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
MemberID: "8989447062e04a818baf9e073fd04fa7",
Schema: "/v2/schemas/member",
Status: "pending",
UpdatedAt: updatedAt,
}, *im)
}
func TestCreate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockCreateRuleResponse(t)
opts := CreateOpts{
IPProtocol: "TCP",
FromPort: 80,
ToPort: 80,
CIDR: "10.10.12.0/24",
}
group, err := Create(client.ServiceClient(), opts).Extract()
th.AssertNoErr(t, err)
expected := &DefaultRule{
ID: ruleID,
FromPort: 80,
ToPort: 80,
IPProtocol: "TCP",
IPRange: secgroups.IPRange{CIDR: "10.10.12.0/24"},
}
th.AssertDeepEquals(t, expected, group)
}
func TestCreate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleCreate(t)
opts := CreateOpts{
Name: "json_rack_instance",
FlavorRef: "1",
Databases: db.BatchCreateOpts{
db.CreateOpts{CharSet: "utf8", Collate: "utf8_general_ci", Name: "sampledb"},
db.CreateOpts{Name: "nextround"},
},
Users: users.BatchCreateOpts{
users.CreateOpts{
Name: "demouser",
Password: "******",
Databases: db.BatchCreateOpts{
db.CreateOpts{Name: "sampledb"},
},
},
},
Size: 2,
}
instance, err := Create(fake.ServiceClient(), opts).Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, &expectedInstance, instance)
}
func TestUploadHandleFlags(t *testing.T) {
app := cli.NewApp()
flagset := flag.NewFlagSet("flags", 1)
flagset.String("name", "", "")
flagset.String("file", "", "")
flagset.String("public-key", "", "")
flagset.Set("name", "keypair1Name")
flagset.Set("public-key", "ssh public key data here")
c := cli.NewContext(app, flagset, nil)
cmd := &commandUpload{
Ctx: &handler.Context{
CLIContext: c,
},
}
expected := &handler.Resource{
Params: ¶msUpload{
opts: &osKeypairs.CreateOpts{
Name: "keypair1Name",
PublicKey: "ssh public key data here",
},
},
}
actual := &handler.Resource{}
err := cmd.HandleFlags(actual)
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, *expected.Params.(*paramsUpload).opts, *actual.Params.(*paramsUpload).opts)
}
func TestListHandleFlags(t *testing.T) {
app := cli.NewApp()
flagset := flag.NewFlagSet("flags", 1)
flagset.String("image", "", "")
flagset.String("flavor", "", "")
flagset.String("name", "", "")
flagset.String("status", "", "")
flagset.String("marker", "", "")
flagset.Set("image", "13ba-75c0-4483-acf9")
flagset.Set("flavor", "1234-b95f-ac5b-cd23")
flagset.Set("name", "server*")
flagset.Set("status", "AVAILABLE")
flagset.Set("marker", "1fd3-4f9f-44df-1b5c")
c := cli.NewContext(app, flagset, nil)
cmd := &commandList{
Ctx: &handler.Context{
CLIContext: c,
},
}
expected := &handler.Resource{
Params: ¶msList{
opts: &osServers.ListOpts{
Image: "13ba-75c0-4483-acf9",
Flavor: "1234-b95f-ac5b-cd23",
Name: "server*",
Status: "AVAILABLE",
Marker: "1fd3-4f9f-44df-1b5c",
},
},
}
actual := &handler.Resource{}
err := cmd.HandleFlags(actual)
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, *expected.Params.(*paramsList).opts, *actual.Params.(*paramsList).opts)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockGetGroupsResponse(t, groupID)
group, err := Get(client.ServiceClient(), groupID).Extract()
th.AssertNoErr(t, err)
expected := &SecurityGroup{
ID: groupID,
Description: "default",
Name: "default",
TenantID: "openstack",
Rules: []Rule{
Rule{
FromPort: 80,
ToPort: 85,
IPProtocol: "TCP",
IPRange: IPRange{CIDR: "0.0.0.0"},
Group: Group{TenantID: "openstack", Name: "default"},
ParentGroupID: groupID,
ID: ruleID,
},
},
}
th.AssertDeepEquals(t, expected, group)
}
func TestValidateTemplate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
os.HandleValidateSuccessfully(t, os.ValidateOutput)
opts := os.ValidateOpts{
Template: `{
"Description": "Simple template to test heat commands",
"Parameters": {
"flavor": {
"Default": "m1.tiny",
"Type": "String",
"NoEcho": "false",
"Description": "",
"Label": "flavor"
}
}
}`,
}
actual, err := Validate(fake.ServiceClient(), opts).Extract()
th.AssertNoErr(t, err)
expected := os.ValidateExpected
th.AssertDeepEquals(t, expected, actual)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
os.HandleGetCDNFlavorSuccessfully(t)
expected := &os.Flavor{
ID: "asia",
Providers: []os.Provider{
os.Provider{
Provider: "ChinaCache",
Links: []gophercloud.Link{
gophercloud.Link{
Href: "http://www.chinacache.com",
Rel: "provider_url",
},
},
},
},
Links: []gophercloud.Link{
gophercloud.Link{
Href: "https://www.poppycdn.io/v1.0/flavors/asia",
Rel: "self",
},
},
}
actual, err := Get(fake.ServiceClient(), "asia").Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected, actual)
}
func TestListVersions(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/", 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, `
{
"versions": [
{
"status": "CURRENT",
"id": "v1.0",
"links": [
{
"href": "http://23.253.228.211:8000/v1",
"rel": "self"
}
]
}
]
}`)
})
count := 0
ListVersions(fake.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := ExtractAPIVersions(page)
if err != nil {
t.Errorf("Failed to extract API versions: %v", err)
return false, err
}
expected := []APIVersion{
APIVersion{
Status: "CURRENT",
ID: "v1.0",
Links: []gophercloud.Link{
gophercloud.Link{
Href: "http://23.253.228.211:8000/v1",
Rel: "self",
},
},
},
}
th.AssertDeepEquals(t, expected, actual)
return true, nil
})
if count != 1 {
t.Errorf("Expected 1 page, got %d", count)
}
}
func TestUpdateUser(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockUpdateUserResponse(t)
id := "c39e3de9be2d4c779f1dfd6abacc176d"
opts := UpdateOpts{
Name: "new_name",
Enabled: Enabled,
Email: "*****@*****.**",
}
user, err := Update(client.ServiceClient(), id, opts).Extract()
th.AssertNoErr(t, err)
expected := &User{
Name: "new_name",
ID: id,
Email: "*****@*****.**",
Enabled: true,
TenantID: "12345",
}
th.AssertDeepEquals(t, expected, user)
}
func TestCreateUser(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockCreateUserResponse(t)
opts := CreateOpts{
Name: "new_user",
TenantID: "12345",
Enabled: Disabled,
Email: "*****@*****.**",
}
user, err := Create(client.ServiceClient(), opts).Extract()
th.AssertNoErr(t, err)
expected := &User{
Name: "new_user",
ID: "c39e3de9be2d4c779f1dfd6abacc176d",
Email: "*****@*****.**",
Enabled: false,
TenantID: "12345",
}
th.AssertDeepEquals(t, expected, user)
}
func TestCreateStackNewTemplateFormat(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleCreateSuccessfully(t, CreateOutput)
template := new(Template)
template.Bin = []byte(`
{
"heat_template_version": "2013-05-23",
"description": "Simple template to test heat commands",
"parameters": {
"flavor": {
"default": "m1.tiny",
"type": "string"
}
}
}`)
createOpts := CreateOpts{
Name: "stackcreated",
Timeout: 60,
TemplateOpts: template,
DisableRollback: Disable,
}
actual, err := Create(fake.ServiceClient(), createOpts).Extract()
th.AssertNoErr(t, err)
expected := CreateExpected
th.AssertDeepEquals(t, expected, actual)
}
func TestResizeContext(t *testing.T) {
cmd := &commandResize{
Ctx: &handler.Context{},
}
expected := cmd.Ctx
actual := cmd.Context()
th.AssertDeepEquals(t, expected, actual)
}