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 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 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 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 TestListURL(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
c := client.ServiceClient()
th.CheckEquals(t, c.Endpoint+"os-keypairs", listURL(c))
}
func TestCreateWithOptionalFields(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,
"shared": true,
"tenant_id": "12345"
}
}
`)
w.WriteHeader(http.StatusCreated)
})
iTrue := true
options := os.CreateOpts{Name: "sample_network", AdminStateUp: &iTrue, Shared: &iTrue, TenantID: "12345"}
_, err := Create(fake.ServiceClient(), options).Extract()
th.AssertNoErr(t, err)
}
func TestChooseVersionFromSuffix(t *testing.T) {
testhelper.SetupHTTP()
defer testhelper.TeardownHTTP()
v2 := &Version{ID: "v2.0", Priority: 2, Suffix: "/v2.0/"}
v3 := &Version{ID: "v3.0", Priority: 3, Suffix: "/v3.0/"}
c := &gophercloud.ProviderClient{
IdentityBase: testhelper.Endpoint(),
IdentityEndpoint: testhelper.Endpoint() + "v2.0/",
}
v, endpoint, err := ChooseVersion(c, []*Version{v2, v3})
if err != nil {
t.Fatalf("Unexpected error from ChooseVersion: %v", err)
}
if v != v2 {
t.Errorf("Expected %#v to win, but %#v did instead", v2, v)
}
expected := testhelper.Endpoint() + "v2.0/"
if endpoint != expected {
t.Errorf("Expected endpoint [%s], but was [%s] instead", expected, endpoint)
}
}
func TestGetRequest(t *testing.T) {
testhelper.SetupHTTP()
defer testhelper.TeardownHTTP()
client := gophercloud.ServiceClient{
ProviderClient: &gophercloud.ProviderClient{
TokenID: "12345abcdef",
},
Endpoint: testhelper.Endpoint(),
}
testhelper.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
testhelper.TestMethod(t, r, "GET")
testhelper.TestHeader(t, r, "Content-Type", "")
testhelper.TestHeader(t, r, "Accept", "application/json")
testhelper.TestHeader(t, r, "X-Auth-Token", "12345abcdef")
testhelper.TestHeader(t, r, "X-Subject-Token", "abcdef12345")
w.WriteHeader(http.StatusOK)
fmt.Fprintf(w, `
{ "token": { "expires_at": "2014-08-29T13:10:01.000000Z" } }
`)
})
token, err := Get(&client, "abcdef12345").Extract()
if err != nil {
t.Errorf("Info returned an error: %v", err)
}
expected, _ := time.Parse(time.UnixDate, "Fri Aug 29 13:10:01 UTC 2014")
if token.ExpiresAt != expected {
t.Errorf("Expected expiration time %s, but was %s", expected.Format(time.UnixDate), token.ExpiresAt.Format(time.UnixDate))
}
}
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)
}
// authTokenPost verifies that providing certain AuthOptions and Scope results in an expected JSON structure.
func authTokenPost(t *testing.T, options gophercloud.AuthOptions, scope *Scope, requestJSON string) {
testhelper.SetupHTTP()
defer testhelper.TeardownHTTP()
client := gophercloud.ServiceClient{
ProviderClient: &gophercloud.ProviderClient{
TokenID: "12345abcdef",
},
Endpoint: testhelper.Endpoint(),
}
testhelper.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
testhelper.TestMethod(t, r, "POST")
testhelper.TestHeader(t, r, "Content-Type", "application/json")
testhelper.TestHeader(t, r, "Accept", "application/json")
testhelper.TestJSONRequest(t, r, requestJSON)
w.WriteHeader(http.StatusCreated)
fmt.Fprintf(w, `{
"token": {
"expires_at": "2014-10-02T13:45:00.000000Z"
}
}`)
})
_, err := Create(&client, options, scope).Extract()
if err != nil {
t.Errorf("Create returned an error: %v", err)
}
}
func TestCreateExtractsTokenFromResponse(t *testing.T) {
testhelper.SetupHTTP()
defer testhelper.TeardownHTTP()
client := gophercloud.ServiceClient{
ProviderClient: &gophercloud.ProviderClient{},
Endpoint: testhelper.Endpoint(),
}
testhelper.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
w.Header().Add("X-Subject-Token", "aaa111")
w.WriteHeader(http.StatusCreated)
fmt.Fprintf(w, `{
"token": {
"expires_at": "2014-10-02T13:45:00.000000Z"
}
}`)
})
options := gophercloud.AuthOptions{UserID: "me", Password: "******"}
token, err := Create(&client, options, nil).Extract()
if err != nil {
t.Fatalf("Create returned an error: %v", err)
}
if token.ID != "aaa111" {
t.Errorf("Expected token to be aaa111, but was %s", token.ID)
}
}
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 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 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 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 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 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 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 TestAuthenticatedClientV2(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/v2.0/tokens", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, `
{
"access": {
"token": {
"id": "01234567890",
"expires": "2014-10-01T10:00:00.000000Z"
},
"serviceCatalog": []
}
}
`)
})
options := gophercloud.AuthOptions{
Username: "******",
APIKey: "09876543210",
IdentityEndpoint: th.Endpoint() + "v2.0/",
}
client, err := AuthenticatedClient(options)
th.AssertNoErr(t, err)
th.CheckEquals(t, "01234567890", client.TokenID)
}
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 TestURLs(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.AssertEquals(t, th.Endpoint()+"v2.0/security-groups", rootURL(fake.ServiceClient()))
th.AssertEquals(t, th.Endpoint()+"v2.0/security-groups/foo", resourceURL(fake.ServiceClient(), "foo"))
}
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 TestCreateURL(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
c := client.ServiceClient()
th.CheckEquals(t, c.Endpoint+"os-volumes_boot", createURL(c))
}
func createMarkerPaged(t *testing.T) Pager {
testhelper.SetupHTTP()
testhelper.Mux.HandleFunc("/page", func(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
ms := r.Form["marker"]
switch {
case len(ms) == 0:
fmt.Fprintf(w, "aaa\nbbb\nccc")
case len(ms) == 1 && ms[0] == "ccc":
fmt.Fprintf(w, "ddd\neee\nfff")
case len(ms) == 1 && ms[0] == "fff":
fmt.Fprintf(w, "ggg\nhhh\niii")
case len(ms) == 1 && ms[0] == "iii":
w.WriteHeader(http.StatusNoContent)
default:
t.Errorf("Request with unexpected marker: [%v]", ms)
}
})
client := createClient()
createPage := func(r PageResult) Page {
p := MarkerPageResult{MarkerPageBase{PageResult: r}}
p.MarkerPageBase.Owner = p
return p
}
return NewPager(client, testhelper.Server.URL+"/page", createPage)
}
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 createLinked(t *testing.T) Pager {
testhelper.SetupHTTP()
testhelper.Mux.HandleFunc("/page1", func(w http.ResponseWriter, r *http.Request) {
w.Header().Add("Content-Type", "application/json")
fmt.Fprintf(w, `{ "ints": [1, 2, 3], "links": { "next": "%s/page2" } }`, testhelper.Server.URL)
})
testhelper.Mux.HandleFunc("/page2", func(w http.ResponseWriter, r *http.Request) {
w.Header().Add("Content-Type", "application/json")
fmt.Fprintf(w, `{ "ints": [4, 5, 6], "links": { "next": "%s/page3" } }`, testhelper.Server.URL)
})
testhelper.Mux.HandleFunc("/page3", func(w http.ResponseWriter, r *http.Request) {
w.Header().Add("Content-Type", "application/json")
fmt.Fprintf(w, `{ "ints": [7, 8, 9], "links": { "next": null } }`)
})
client := createClient()
createPage := func(r PageResult) Page {
return LinkedPageResult{LinkedPageBase{PageResult: r}}
}
return NewPager(client, testhelper.Server.URL+"/page1", createPage)
}
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 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 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"])
}