func TestDeleteExecute(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/foo/bar", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(204) }) fs := flag.NewFlagSet("flags", 1) fs.String("container", "", "") fs.String("name", "", "") fs.Set("container", "foo") fs.Set("name", "bar") cmd := newDelCmd(fs) cmd.Ctx.ServiceClient = client.ServiceClient() res := &handler.Resource{ Params: ¶msDelete{container: "foo", object: "bar"}, } cmd.Execute(res) th.AssertNoErr(t, res.Err) }
func TestListHandleSingle(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() setupList(t) fs := flag.NewFlagSet("flags", 1) fs.String("container", "", "") fs.Set("container", "testContainer") cmd := newListCmd(fs) cmd.Ctx.ServiceClient = client.ServiceClient() expected := &handler.Resource{ Params: ¶msList{ container: "testContainer", }, } actual := &handler.Resource{ Params: ¶msList{}, } err := cmd.HandleSingle(actual) th.AssertNoErr(t, err) th.AssertEquals(t, expected.Params.(*paramsList).container, actual.Params.(*paramsList).container) }
func TestCreateURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() th.CheckEquals(t, c.Endpoint+"os-volumes_boot", createURL(c)) }
func TestDeleteHandleSingle(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/foo/bar", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(204) }) fs := flag.NewFlagSet("flags", 1) fs.String("container", "", "") fs.String("name", "", "") fs.Set("container", "foo") fs.Set("name", "bar") cmd := newDelCmd(fs) cmd.Ctx.ServiceClient = client.ServiceClient() expected := &handler.Resource{ Params: ¶msDelete{ object: "bar", }, } actual := &handler.Resource{ Params: ¶msDelete{}, } err := cmd.HandleSingle(actual) th.AssertNoErr(t, err) th.AssertEquals(t, expected.Params.(*paramsDelete).object, actual.Params.(*paramsDelete).object) }
func TestUploadExecute(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/foo/bar", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "PUT") w.Header().Add("Content-Type", "text/plain") hash := md5.New() io.WriteString(hash, "hodor") localChecksum := hash.Sum(nil) w.Header().Set("ETag", fmt.Sprintf("%x", localChecksum)) w.WriteHeader(201) fmt.Fprintf(w, `hodor`) }) fs := flag.NewFlagSet("flags", 1) cmd := newUpCmd(fs) cmd.Ctx.ServiceClient = client.ServiceClient() res := &handler.Resource{ Params: ¶msUpload{ container: "foo", object: "bar", stream: strings.NewReader("hodor"), opts: osObjects.CreateOpts{}, }, } cmd.Execute(res) th.AssertNoErr(t, res.Err) th.AssertEquals(t, "Successfully uploaded object [bar] to container [foo]\n", res.Result) }
func TestListServers(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleServerListSuccessfully(t) pages := 0 err := List(client.ServiceClient(), ListOpts{}).EachPage(func(page pagination.Page) (bool, error) { pages++ actual, err := ExtractServers(page) if err != nil { return false, err } if len(actual) != 2 { t.Fatalf("Expected 2 servers, got %d", len(actual)) } th.CheckDeepEquals(t, ServerHerp, actual[0]) th.CheckDeepEquals(t, ServerDerp, actual[1]) return true, nil }) th.AssertNoErr(t, err) if pages != 1 { t.Errorf("Expected 1 page, saw %d", pages) } }
func TestCreateExecute(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/container1", func(w http.ResponseWriter, r *http.Request) { w.Header().Add("X-Container-Meta-Foo", "bar") w.Header().Add("X-Container-Meta-Key", "val") w.Header().Add("X-Trans-Id", "1234567") w.WriteHeader(http.StatusNoContent) }) cmd := &commandCreate{ Ctx: &handler.Context{ ServiceClient: client.ServiceClient(), }, } actual := &handler.Resource{ Params: ¶msCreate{ opts: containers.CreateOpts{ Metadata: map[string]string{ "key": "val", "foo": "bar", }, }, container: "container1", }, } cmd.Execute(actual) th.AssertNoErr(t, actual.Err) }
func TestGenerateExecute(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/os-keypairs", func(w http.ResponseWriter, r *http.Request) { w.Header().Add("Content-Type", "application/json") fmt.Fprintf(w, `{"keypair":{}}`) }) app := cli.NewApp() flagset := flag.NewFlagSet("flags", 1) flagset.String("output", "json", "") c := cli.NewContext(app, flagset, nil) cmd := &commandGenerate{ Ctx: &handler.Context{ CLIContext: c, ServiceClient: client.ServiceClient(), }, } actual := &handler.Resource{ Params: ¶msGenerate{ opts: &osKeypairs.CreateOpts{ Name: "keypair1Name", }, }, } cmd.Execute(actual) th.AssertNoErr(t, actual.Err) }
func tokenPost(t *testing.T, options gophercloud.AuthOptions, requestJSON string) os.CreateResult { th.SetupHTTP() defer th.TeardownHTTP() os.HandleTokenPost(t, requestJSON) return Create(client.ServiceClient(), WrapOptions(options)) }
func TestListAll(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() MockListResponse(t) allPages, err := List(client.ServiceClient(), &ListOpts{}).AllPages() th.AssertNoErr(t, err) actual, err := ExtractVolumes(allPages) th.AssertNoErr(t, err) expected := []Volume{ Volume{ ID: "289da7f8-6440-407c-9fb4-7db01ec49164", Name: "vol-001", }, Volume{ ID: "96c3bda7-c82a-4f50-be73-ca7621794835", Name: "vol-002", }, } th.CheckDeepEquals(t, expected, actual) }
func TestGetHandleSingle(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/foo/bar", func(w http.ResponseWriter, r *http.Request) { w.Header().Add("Content-Type", "text/plain") fmt.Fprintf(w, `hodor`) }) fs := flag.NewFlagSet("flags", 1) fs.String("container", "", "") fs.String("name", "", "") fs.Set("container", "foo") fs.Set("name", "bar") cmd := newGetCmd(fs) cmd.Ctx.ServiceClient = client.ServiceClient() expected := &handler.Resource{ Params: ¶msGet{ object: "bar", }, } actual := &handler.Resource{ Params: ¶msGet{}, } err := cmd.HandleSingle(actual) th.AssertNoErr(t, err) th.AssertEquals(t, expected.Params.(*paramsGet).object, actual.Params.(*paramsGet).object) }
func TestListImageDetails(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/images/detail", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "GET") th.TestHeader(t, r, "X-Auth-Token", client.TokenID) w.Header().Add("Content-Type", "application/json") r.ParseForm() marker := r.Form.Get("marker") switch marker { case "": fmt.Fprintf(w, ListOutput) case "e19a734c-c7e6-443a-830c-242209c4d65d": fmt.Fprintf(w, `{ "images": [] }`) default: t.Fatalf("Unexpected marker: [%s]", marker) } }) count := 0 err := ListDetail(client.ServiceClient(), nil).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractImages(page) th.AssertNoErr(t, err) th.CheckDeepEquals(t, ExpectedImageSlice, actual) return true, nil }) th.AssertNoErr(t, err) th.CheckEquals(t, 1, count) }
func TestList(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.MockListResponse(t) count := 0 err := List(fake.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractSnapshots(page) if err != nil { t.Errorf("Failed to extract snapshots: %v", err) return false, err } expected := []Snapshot{ Snapshot{ ID: "289da7f8-6440-407c-9fb4-7db01ec49164", Name: "snapshot-001", }, Snapshot{ ID: "96c3bda7-c82a-4f50-be73-ca7621794835", Name: "snapshot-002", }, } th.CheckDeepEquals(t, expected, actual) return true, nil }) th.AssertEquals(t, 1, count) th.AssertNoErr(t, err) }
func TestRebuildExecute(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/servers/server1/action", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusAccepted) w.Header().Add("Content-Type", "application/json") fmt.Fprintf(w, `{"server":{}}`) }) cmd := &commandRebuild{ Ctx: &handler.Context{ ServiceClient: client.ServiceClient(), }, } actual := &handler.Resource{ Params: ¶msRebuild{ serverID: "server1", opts: &servers.RebuildOpts{ Name: "server1Rename", ImageID: "123456789", AdminPass: "******", DiskConfig: diskconfig.Auto, }, }, } cmd.Execute(actual) th.AssertNoErr(t, actual.Err) }
func TestCreatePreTable(t *testing.T) { cmd := &commandAbandon{ Ctx: &handler.Context{ ServiceClient: client.ServiceClient(), }, } resource := &handler.Resource{ Params: ¶msCreate{}, } expected := "{\"ID\":\"16ef0584-4458-41eb-87c8-0dc8d5f66c87\",\"Links\":[{\"Href\":\"http://168.28.170.117:8004/v1/98606384f58drad0bhdb7d02779549ac/stacks/stackcreated/16ef0584-4458-41eb-87c8-0dc8d5f66c87\",\"Rel\":\"self\"}]}" resource.Result = &osStacks.CreatedStack{ ID: "16ef0584-4458-41eb-87c8-0dc8d5f66c87", Links: []gophercloud.Link{ gophercloud.Link{ Href: "http://168.28.170.117:8004/v1/98606384f58drad0bhdb7d02779549ac/stacks/stackcreated/16ef0584-4458-41eb-87c8-0dc8d5f66c87", Rel: "self", }, }, } err := cmd.PreTable(resource) th.AssertNoErr(t, err) actual, _ := json.Marshal(resource.Result) th.AssertEquals(t, expected, string(actual)) }
func TestCreateExecute(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/stacks", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "POST") w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusAccepted) fmt.Fprintf(w, `{"stack": {"id": "3095aefc-09fb-4bc7-b1f0-f21a304e864c"}}`) }) cmd := &commandCreate{ Ctx: &handler.Context{ ServiceClient: client.ServiceClient(), }, } templateOpts := new(osStacks.Template) templateOpts.Bin = []byte(`"heat_template_version": "2014-10-16"`) actual := &handler.Resource{ Params: ¶msCreate{ opts: &osStacks.CreateOpts{ Name: "stack1", TemplateOpts: templateOpts, Parameters: map[string]string{ "img": "foo", "flavor": "bar", }, }, }, } cmd.Execute(actual) th.AssertNoErr(t, actual.Err) }
func TestListURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() th.CheckEquals(t, c.Endpoint+"os-keypairs", listURL(c)) }
func TestRebootHandleSingle(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("name", "", "") flagset.Set("name", "server1Name") c := cli.NewContext(app, flagset, nil) cmd := &commandReboot{ Ctx: &handler.Context{ CLIContext: c, ServiceClient: client.ServiceClient(), }, } expected := &handler.Resource{ Params: ¶msReboot{ serverID: "server1", }, } actual := &handler.Resource{ Params: ¶msReboot{}, } err := cmd.HandleSingle(actual) th.AssertNoErr(t, err) th.AssertEquals(t, expected.Params.(*paramsReboot).serverID, actual.Params.(*paramsReboot).serverID) }
func TestDeleteExecute(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/container1", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusNoContent) }) app := cli.NewApp() flagset := flag.NewFlagSet("flags", 1) flagset.String("name", "", "") flagset.Set("name", "container1") c := cli.NewContext(app, flagset, nil) cmd := &commandDelete{ Ctx: &handler.Context{ ServiceClient: client.ServiceClient(), CLIContext: c, }, } actual := &handler.Resource{ Params: ¶msDelete{ container: "container1", }, } cmd.Execute(actual) th.AssertNoErr(t, actual.Err) }
func TestDeleteURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() th.CheckEquals(t, c.Endpoint+"os-keypairs/wat", deleteURL(c, "wat")) }
func TestUpdateStack(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleUpdateSuccessfully(t) updateOpts := UpdateOpts{ Template: ` { "heat_template_version": "2013-05-23", "description": "Simple template to test heat commands", "parameters": { "flavor": { "default": "m1.tiny", "type": "string" } }, "resources": { "hello_world": { "type":"OS::Nova::Server", "properties": { "key_name": "heat_key", "flavor": { "get_param": "flavor" }, "image": "ad091b52-742f-469e-8f3c-fd81cadf0743", "user_data": "#!/bin/bash -xv\necho \"hello world\" > /root/hello-world.txt\n" } } } }`, } err := Update(fake.ServiceClient(), "gophercloud-test-stack-2", "db6977b2-27aa-4775-9ae7-6213212d4ada", updateOpts).ExtractErr() th.AssertNoErr(t, err) }
func TestListEventsExecute(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/stacks/stack1/id1/resources/resource1/events", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "GET") w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusOK) fmt.Fprint(w, `{"events": [{"event_time": "2014-06-03T20:59:46", "resource_name":"resource1"}]}`) }) cmd := &commandListEvents{ Ctx: &handler.Context{ ServiceClient: client.ServiceClient(), }, } actual := &handler.Resource{ Params: ¶msListEvents{ stackName: "stack1", stackID: "id1", resourceName: "resource1", opts: &osStackEvents.ListResourceEventsOpts{}, }, } cmd.Execute(actual) th.AssertNoErr(t, actual.Err) }
func TestGetExecute(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/foo/bar", func(w http.ResponseWriter, r *http.Request) { w.Header().Add("Content-Type", "text/plain") fmt.Fprintf(w, `hodor`) }) fs := flag.NewFlagSet("flags", 1) fs.String("container", "", "") fs.String("name", "", "") fs.Set("container", "foo") fs.Set("name", "bar") cmd := newGetCmd(fs) cmd.Ctx.ServiceClient = client.ServiceClient() res := &handler.Resource{ Params: ¶msGet{container: "foo", object: "bar"}, } cmd.Execute(res) th.AssertNoErr(t, res.Err) th.AssertEquals(t, "text/plain", res.Result.(map[string]interface{})["ContentType"]) }
func TestGetContainers(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleGetContainerSuccessfully(t) _, err := Get(fake.ServiceClient(), "testContainer").ExtractMetadata() th.CheckNoErr(t, err) }
func TestDeleteStack(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleDeleteSuccessfully(t) err := Delete(fake.ServiceClient(), "gophercloud-test-stack-2", "db6977b2-27aa-4775-9ae7-6213212d4ada").ExtractErr() th.AssertNoErr(t, err) }
func TestDeleteServer(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleServerDeletionSuccessfully(t) res := Delete(client.ServiceClient(), "asdfasdfasdf") th.AssertNoErr(t, res.Err) }
func TestReboot(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleRebootSuccessfully(t) res := Reboot(client.ServiceClient(), "1234asdf", os.SoftReboot) th.AssertNoErr(t, res.Err) }
func TestDeleteObject(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleDeleteObjectSuccessfully(t) res := Delete(fake.ServiceClient(), "testContainer", "testObject", nil) th.AssertNoErr(t, res.Err) }
func TestDelete(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleDeleteSuccessfully(t) err := Delete(client.ServiceClient(), "deletedkey").ExtractErr() th.AssertNoErr(t, err) }
func TestChangeAdminPassword(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleAdminPasswordChangeSuccessfully(t) res := ChangeAdminPassword(client.ServiceClient(), "1234asdf", "new-password") th.AssertNoErr(t, res.Err) }