func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/v2.0/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, []AllocationPool{
AllocationPool{
Start: "192.0.0.2",
End: "192.255.255.254",
},
})
th.AssertDeepEquals(t, s.HostRoutes, []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 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 := 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{
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")
}
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 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 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("sort-dir", "", "")
flagset.String("sort-key", "", "")
flagset.String("name", "", "")
flagset.String("status", "", "")
flagset.String("marker", "", "")
flagset.Set("sort-dir", "asc")
flagset.Set("sort-key", "name")
flagset.Set("name", "stacks*")
flagset.Set("status", "CREATE_COMPLETE")
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: &osStacks.ListOpts{
SortKey: "name",
SortDir: "asc",
Name: "stacks*",
Status: "CREATE_COMPLETE",
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 TestLimitJSONFields(t *testing.T) {
m := map[string]interface{}{"id": "12345", "name": "name", "status": "actvive"}
keys := []string{"id", "status"}
expected := map[string]interface{}{"id": "12345", "status": "actvive"}
actual := limitJSONFields(m, keys)
th.AssertDeepEquals(t, expected, actual)
keys = []string{}
expected = m
actual = limitJSONFields(m, keys)
th.AssertDeepEquals(t, expected, actual)
keys = []string{"not", "there"}
expected = map[string]interface{}{}
actual = limitJSONFields(m, keys)
th.AssertDeepEquals(t, expected, actual)
}
func TestRebootContext(t *testing.T) {
cmd := &commandReboot{
Ctx: &handler.Context{},
}
expected := cmd.Ctx
actual := cmd.Context()
th.AssertDeepEquals(t, expected, actual)
}
func TestDlErrWhenCtnrMissing(t *testing.T) {
fs := flag.NewFlagSet("flags", 1)
err := newDlCmd(fs).HandleFlags(&handler.Resource{})
expected := output.ErrMissingFlag{Msg: "--container is required."}
th.AssertDeepEquals(t, expected, err)
}
func TestDlErrWhenNameMissing(t *testing.T) {
fs := flag.NewFlagSet("flags", 1)
fs.String("container", "", "")
fs.Set("container", "foo")
err := newDlCmd(fs).HandleFlags(&handler.Resource{})
expected := output.ErrMissingFlag{Msg: "--name is required."}
th.AssertDeepEquals(t, expected, err)
}
func TestGetMetadata(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleMetadataGetSuccessfully(t)
expected := map[string]string{"foo": "bar", "this": "that"}
actual, err := Metadata(client.ServiceClient(), "1234asdf").Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected, actual)
}
func TestCreateMetadatum(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleMetadatumCreateSuccessfully(t)
expected := map[string]string{"foo": "bar"}
actual, err := CreateMetadatum(client.ServiceClient(), "1234asdf", MetadatumOpts{"foo": "bar"}).Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected, actual)
}
func TestGetResourceTemplate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleGetTemplateSuccessfully(t, GetTemplateOutput)
actual, err := Template(fake.ServiceClient(), "OS::Heat::AResourceName").Extract()
th.AssertNoErr(t, err)
expected := GetTemplateExpected
th.AssertDeepEquals(t, expected, actual)
}
func TestResourceMetadata(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleMetadataSuccessfully(t, MetadataOutput)
actual, err := Metadata(fake.ServiceClient(), "teststack", "0b1771bd-9336-4f2b-ae86-a80f971faf1e", "wordpress_instance").Extract()
th.AssertNoErr(t, err)
expected := MetadataExpected
th.AssertDeepEquals(t, expected, actual)
}
func TestGetResourceSchema(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
os.HandleGetSchemaSuccessfully(t, os.GetSchemaOutput)
actual, err := Schema(fake.ServiceClient(), "OS::Heat::AResourceName").Extract()
th.AssertNoErr(t, err)
expected := os.GetSchemaExpected
th.AssertDeepEquals(t, expected, actual)
}
func TestFindResources(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
os.HandleFindSuccessfully(t, os.FindOutput)
actual, err := Find(fake.ServiceClient(), "hello_world").Extract()
th.AssertNoErr(t, err)
expected := os.FindExpected
th.AssertDeepEquals(t, expected, actual)
}
func TestGetTemplate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleGetSuccessfully(t, GetOutput)
actual, err := Get(fake.ServiceClient()).Extract()
th.AssertNoErr(t, err)
expected := GetExpected
th.AssertDeepEquals(t, expected, actual)
}
func TestGetEvent(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleGetSuccessfully(t, GetOutput)
actual, err := Get(fake.ServiceClient(), "hello_world", "49181cd6-169a-4130-9455-31185bbfc5bf", "my_resource", "93940999-7d40-44ae-8de4-19624e7b8d18").Extract()
th.AssertNoErr(t, err)
expected := GetExpected
th.AssertDeepEquals(t, expected, actual)
}
func TestGetTemplate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
os.HandleGetSuccessfully(t, os.GetOutput)
actual, err := Get(fake.ServiceClient(), "postman_stack", "16ef0584-4458-41eb-87c8-0dc8d5f66c87").Extract()
th.AssertNoErr(t, err)
expected := os.GetExpected
th.AssertDeepEquals(t, expected, actual)
}
func TestFindEvents(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleFindSuccessfully(t, FindOutput)
actual, err := Find(fake.ServiceClient(), "postman_stack").Extract()
th.AssertNoErr(t, err)
expected := FindExpected
th.AssertDeepEquals(t, expected, actual)
}
func TestGetHandleFlags(t *testing.T) {
cmd := &commandGet{
Ctx: &handler.Context{},
}
expected := &handler.Resource{
Params: ¶msGet{},
}
actual := &handler.Resource{}
err := cmd.HandleFlags(actual)
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected.Params.(*paramsGet), actual.Params.(*paramsGet))
}
func TestQueriesAreEscaped(t *testing.T) {
type foo struct {
Name string `q:"something"`
Shape string `q:"else"`
}
expected := &url.URL{RawQuery: "else=Triangl+e&something=blah%2B%3F%21%21foo"}
actual, err := BuildQueryString(foo{Name: "blah+?!!foo", Shape: "Triangl e"})
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected, actual)
}
func TestListContext(t *testing.T) {
app := cli.NewApp()
flagset := flag.NewFlagSet("flags", 1)
c := cli.NewContext(app, flagset, nil)
cmd := &commandList{
Ctx: &handler.Context{
CLIContext: c,
},
}
expected := cmd.Ctx
actual := cmd.Context()
th.AssertDeepEquals(t, expected, actual)
}
func TestCreateHandleFlags(t *testing.T) {
app := cli.NewApp()
flagset := flag.NewFlagSet("flags", 1)
flagset.String("image-id", "", "")
flagset.String("flavor-id", "", "")
flagset.String("security-groups", "", "")
flagset.String("networks", "", "")
flagset.String("metadata", "", "")
flagset.String("admin-pass", "", "")
flagset.String("keypair", "", "")
flagset.Set("image-id", "13ba-75c0-4483-acf9")
flagset.Set("flavor-id", "1234-b95f-ac5b-cd23")
flagset.Set("security-groups", "sg1,sg2,sg3")
flagset.Set("networks", "1111-2222-3333-4444,5555-7777-8888-9999")
flagset.Set("metadata", "img=foo,flavor=bar")
flagset.Set("admin-pass", "secret")
flagset.Set("keypair", "kp1")
c := cli.NewContext(app, flagset, nil)
cmd := &commandCreate{
Ctx: &handler.Context{
CLIContext: c,
},
}
expected := &handler.Resource{
Params: ¶msCreate{
opts: &servers.CreateOpts{
ImageRef: "13ba-75c0-4483-acf9",
FlavorRef: "1234-b95f-ac5b-cd23",
SecurityGroups: []string{"sg1", "sg2", "sg3"},
Networks: []osServers.Network{
{
UUID: "1111-2222-3333-4444",
},
{
UUID: "5555-7777-8888-9999",
},
},
Metadata: map[string]string{
"img": "foo",
"flavor": "bar",
},
AdminPass: "******",
KeyPair: "kp1",
},
},
}
actual := &handler.Resource{}
err := cmd.HandleFlags(actual)
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, *expected.Params.(*paramsCreate).opts, *actual.Params.(*paramsCreate).opts)
}
func TestGenerateHandleFlags(t *testing.T) {
cmd := &commandGenerate{
Ctx: &handler.Context{},
}
expected := &handler.Resource{
Params: ¶msGenerate{
opts: &osKeypairs.CreateOpts{},
},
}
actual := &handler.Resource{}
err := cmd.HandleFlags(actual)
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, *expected.Params.(*paramsGenerate).opts, *actual.Params.(*paramsGenerate).opts)
}
func TestUpdateMetadata(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleMetadataUpdateSuccessfully(t)
expected := map[string]string{"foo": "baz", "this": "those"}
actual, err := UpdateMetadata(client.ServiceClient(), "1234asdf", MetadataOpts{
"foo": "baz",
"this": "those",
}).Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected, actual)
}
func TestRebuildHandleFlags(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/servers/detail", func(w http.ResponseWriter, r *http.Request) {
w.Header().Add("Content-Type", "application/json")
fmt.Fprintf(w, `{"servers":[{"ID":"server1","Name":"server1Name"}]}`)
})
app := cli.NewApp()
flagset := flag.NewFlagSet("flags", 1)
flagset.String("id", "", "")
flagset.String("image-id", "", "")
flagset.String("admin-pass", "", "")
flagset.String("ipv4", "", "")
flagset.String("ipv6", "", "")
flagset.String("metadata", "", "")
flagset.String("rename", "", "")
flagset.Set("id", "server1")
flagset.Set("image-id", "123456789")
flagset.Set("admin-pass", "secret")
flagset.Set("ipv4", "123.45.67.89")
flagset.Set("metadata", "img=bar,flavor=foo")
flagset.Set("rename", "server1Rename")
c := cli.NewContext(app, flagset, nil)
cmd := &commandRebuild{
Ctx: &handler.Context{
CLIContext: c,
},
}
expected := &handler.Resource{
Params: ¶msRebuild{
opts: &servers.RebuildOpts{
ImageID: "123456789",
AdminPass: "******",
AccessIPv4: "123.45.67.89",
Metadata: map[string]string{
"img": "bar",
"flavor": "foo",
},
Name: "server1Rename",
},
serverID: "server1",
},
}
actual := &handler.Resource{}
err := cmd.HandleFlags(actual)
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, *expected.Params.(*paramsRebuild).opts, *actual.Params.(*paramsRebuild).opts)
}
func TestCreate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/networks", func(w http.ResponseWriter, r *http.Request) {
th.TestMethod(t, r, "POST")
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": "sample_network",
"admin_state_up": true
}
}
`)
w.Header().Add("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
fmt.Fprintf(w, `
{
"network": {
"status": "ACTIVE",
"subnets": [],
"name": "net1",
"admin_state_up": true,
"tenant_id": "9bacb3c5d39d41a79512987f338cf177",
"shared": false,
"id": "4e8e5957-649f-477b-9e5b-f1f75b21c03c"
}
}
`)
})
iTrue := true
options := os.CreateOpts{Name: "sample_network", AdminStateUp: &iTrue}
n, err := Create(fake.ServiceClient(), options).Extract()
th.AssertNoErr(t, err)
th.AssertEquals(t, n.Status, "ACTIVE")
th.AssertDeepEquals(t, n.Subnets, []string{})
th.AssertEquals(t, n.Name, "net1")
th.AssertEquals(t, n.AdminStateUp, true)
th.AssertEquals(t, n.TenantID, "9bacb3c5d39d41a79512987f338cf177")
th.AssertEquals(t, n.Shared, false)
th.AssertEquals(t, n.ID, "4e8e5957-649f-477b-9e5b-f1f75b21c03c")
}
func TestErrorIsRaisedForChecksumMismatch(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/testContainer/testObject", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("ETag", "acbd18db4cc2f85cedef654fccc4a4d8")
w.WriteHeader(http.StatusCreated)
})
content := strings.NewReader("The sky was the color of television, tuned to a dead channel.")
res := Create(fake.ServiceClient(), "testContainer", "testObject", content, &CreateOpts{})
err := fmt.Errorf("Local checksum does not match API ETag header")
th.AssertDeepEquals(t, err, res.Err)
}
func TestCreateHandleFlags(t *testing.T) {
app := cli.NewApp()
flagset := flag.NewFlagSet("flags", 1)
flagset.String("name", "", "")
flagset.String("disable-rollback", "", "")
flagset.String("template-file", "", "")
flagset.String("environment-file", "", "")
flagset.String("timeout", "", "")
flagset.String("parameters", "", "")
flagset.Set("name", "stack1")
flagset.Set("disable-rollback", "true")
flagset.Set("template-file", "mytemplate.yaml")
flagset.Set("environment-file", "myenvironment.yaml")
flagset.Set("timeout", "300")
flagset.Set("parameters", "img=foo,flavor=bar")
c := cli.NewContext(app, flagset, nil)
cmd := &commandCreate{
Ctx: &handler.Context{
CLIContext: c,
},
}
disableRollback := true
templateOpts := new(osStacks.Template)
templateOpts.URL = "mytemplate.yaml"
environmentOpts := new(osStacks.Environment)
environmentOpts.URL = "myenvironment.yaml"
expected := &handler.Resource{
Params: ¶msCreate{
opts: &osStacks.CreateOpts{
Name: "stack1",
TemplateOpts: templateOpts,
EnvironmentOpts: environmentOpts,
DisableRollback: &disableRollback,
Timeout: 300,
Parameters: map[string]string{
"img": "foo",
"flavor": "bar",
},
},
},
}
actual := &handler.Resource{}
err := cmd.HandleFlags(actual)
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, *expected.Params.(*paramsCreate).opts, *actual.Params.(*paramsCreate).opts)
}