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) } }
// IsSuccessful ensures that a CreateResult was successful and contains the correct token and // service catalog. func IsSuccessful(t *testing.T, result CreateResult) { token, err := result.ExtractToken() th.AssertNoErr(t, err) th.CheckDeepEquals(t, ExpectedToken, token) serviceCatalog, err := result.ExtractServiceCatalog() th.AssertNoErr(t, err) th.CheckDeepEquals(t, ExpectedServiceCatalog, serviceCatalog) }
func TestMaybeInt(t *testing.T) { testInt := 0 var expected *int actual := MaybeInt(testInt) th.CheckDeepEquals(t, expected, actual) testInt = 4 expected = &testInt actual = MaybeInt(testInt) th.CheckDeepEquals(t, expected, actual) }
func TestMaybeString(t *testing.T) { testString := "" var expected *string actual := MaybeString(testString) th.CheckDeepEquals(t, expected, actual) testString = "carol" expected = &testString actual = MaybeString(testString) th.CheckDeepEquals(t, expected, actual) }
func TestApplyDefaultsToEndpointOpts(t *testing.T) { eo := EndpointOpts{Availability: AvailabilityPublic} eo.ApplyDefaults("compute") expected := EndpointOpts{Availability: AvailabilityPublic, Type: "compute"} th.CheckDeepEquals(t, expected, eo) eo = EndpointOpts{Type: "compute"} eo.ApplyDefaults("object-store") expected = EndpointOpts{Availability: AvailabilityPublic, Type: "compute"} th.CheckDeepEquals(t, expected, eo) }
func TestListAllServers(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleServerListSuccessfully(t) allPages, err := List(client.ServiceClient(), ListOpts{}).AllPages() th.AssertNoErr(t, err) actual, err := ExtractServers(allPages) th.AssertNoErr(t, err) th.CheckDeepEquals(t, ServerHerp, actual[0]) th.CheckDeepEquals(t, ServerDerp, actual[1]) }
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 TestBuildHeaders(t *testing.T) { testStruct := struct { Accept string `h:"Accept"` Num int `h:"Number,required"` Style bool `h:"Style"` }{ Accept: "application/json", Num: 4, Style: true, } expected := map[string]string{"Accept": "application/json", "Number": "4", "Style": "true"} actual, err := BuildHeaders(&testStruct) th.CheckNoErr(t, err) th.CheckDeepEquals(t, expected, actual) testStruct.Num = 0 _, err = BuildHeaders(&testStruct) if err == nil { t.Errorf("Expected error: 'Required header not set'") } _, err = BuildHeaders(map[string]interface{}{"Number": 4}) if err == nil { t.Errorf("Expected error: 'Options type is not a struct'") } }
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 TestEnumerateMarker(t *testing.T) { pager := createMarkerPaged(t) defer testhelper.TeardownHTTP() callCount := 0 err := pager.EachPage(func(page 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 tokenPostErr(t *testing.T, options gophercloud.AuthOptions, expectedErr error) { th.SetupHTTP() defer th.TeardownHTTP() HandleTokenPost(t, "") actualErr := Create(client.ServiceClient(), AuthOptions{options}).Err th.CheckDeepEquals(t, expectedErr, actualErr) }
func TestAuthenticatedHeaders(t *testing.T) { p := &ProviderClient{ TokenID: "1234", } expected := map[string]string{"X-Auth-Token": "1234"} actual := p.AuthenticatedHeaders() th.CheckDeepEquals(t, expected, actual) }
func TestBuildQueryString(t *testing.T) { type testVar string opts := struct { J int `q:"j"` R string `q:"r,required"` C bool `q:"c"` S []string `q:"s"` TS []testVar `q:"ts"` TI []int `q:"ti"` }{ J: 2, R: "red", C: true, S: []string{"one", "two", "three"}, TS: []testVar{"a", "b"}, TI: []int{1, 2}, } expected := &url.URL{RawQuery: "c=true&j=2&r=red&s=one&s=two&s=three&ti=1&ti=2&ts=a&ts=b"} actual, err := BuildQueryString(&opts) if err != nil { t.Errorf("Error building query string: %v", err) } th.CheckDeepEquals(t, expected, actual) opts = struct { J int `q:"j"` R string `q:"r,required"` C bool `q:"c"` S []string `q:"s"` TS []testVar `q:"ts"` TI []int `q:"ti"` }{ J: 2, C: true, } _, err = BuildQueryString(&opts) if err == nil { t.Errorf("Expected error: 'Required field not set'") } th.CheckDeepEquals(t, expected, actual) _, err = BuildQueryString(map[string]interface{}{"Number": 4}) if err == nil { t.Errorf("Expected error: 'Options type is not a struct'") } }
func TestGet(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleGetSuccessfully(t) actual, err := Get(client.ServiceClient(), "firstkey").Extract() th.AssertNoErr(t, err) th.CheckDeepEquals(t, &os.FirstKeyPair, actual) }
func TestGetObject(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleGetObjectSuccessfully(t) expected := map[string]string{"Gophercloud-Test": "objects"} actual, err := Get(fake.ServiceClient(), "testContainer", "testObject", nil).ExtractMetadata() th.AssertNoErr(t, err) th.CheckDeepEquals(t, expected, actual) }
func TestList(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/v2.0/security-groups", 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_groups": [ { "description": "default", "id": "85cc3048-abc3-43cc-89b3-377341426ac5", "name": "default", "security_group_rules": [], "tenant_id": "e4f50856753b4dc6afee5fa6b9b6c550" } ] } `) }) count := 0 List(fake.ServiceClient(), ListOpts{}).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractGroups(page) if err != nil { t.Errorf("Failed to extract secgroups: %v", err) return false, err } expected := []SecGroup{ SecGroup{ Description: "default", ID: "85cc3048-abc3-43cc-89b3-377341426ac5", Name: "default", Rules: []rules.SecGroupRule{}, TenantID: "e4f50856753b4dc6afee5fa6b9b6c550", }, } th.CheckDeepEquals(t, expected, actual) return true, nil }) if count != 1 { t.Errorf("Expected 1 page, got %d", count) } }
func TestGet(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleGetSuccessfully(t) aId := "a26887c6-c47b-4654-abb5-dfadf7d3f804" serverId := "4d8c3732-a248-40ed-bebc-539a6ffd25c0" actual, err := Get(client.ServiceClient(), serverId, aId).Extract() th.AssertNoErr(t, err) th.CheckDeepEquals(t, &SecondVolumeAttachment, actual) }
func TestCreate(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleCreateSuccessfully(t) actual, err := Create(client.ServiceClient(), os.CreateOpts{ Name: "createdkey", }).Extract() th.AssertNoErr(t, err) th.CheckDeepEquals(t, &os.CreatedKeyPair, actual) }
func TestListAllContainerNames(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleListContainerNamesSuccessfully(t) allPages, err := List(fake.ServiceClient(), &ListOpts{Full: false}).AllPages() th.AssertNoErr(t, err) actual, err := ExtractNames(allPages) th.AssertNoErr(t, err) th.CheckDeepEquals(t, ExpectedListNames, actual) }
func TestAllPagesLinked(t *testing.T) { pager := createLinked(t) defer testhelper.TeardownHTTP() page, err := pager.AllPages() testhelper.AssertNoErr(t, err) expected := []int{1, 2, 3, 4, 5, 6, 7, 8, 9} actual, err := ExtractLinkedInts(page) testhelper.AssertNoErr(t, err) testhelper.CheckDeepEquals(t, expected, actual) }
func TestAllPagesSingle(t *testing.T) { pager := setupSinglePaged() defer testhelper.TeardownHTTP() page, err := pager.AllPages() testhelper.AssertNoErr(t, err) expected := []int{1, 2, 3} actual, err := ExtractSingleInts(page) testhelper.AssertNoErr(t, err) testhelper.CheckDeepEquals(t, expected, actual) }
func TestImport(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleImportSuccessfully(t) actual, err := Create(client.ServiceClient(), os.CreateOpts{ Name: "importedkey", PublicKey: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDx8nkQv/zgGgB4rMYmIf+6A4l6Rr+o/6lHBQdW5aYd44bd8JttDCE/F/pNRr0lRE+PiqSPO8nDPHw0010JeMH9gYgnnFlyY3/OcJ02RhIPyyxYpv9FhY+2YiUkpwFOcLImyrxEsYXpD/0d3ac30bNH6Sw9JD9UZHYcpSxsIbECHw== Generated by Nova", }).Extract() th.AssertNoErr(t, err) th.CheckDeepEquals(t, &os.ImportedKeyPair, actual) }
func TestAllPagesMarker(t *testing.T) { pager := createMarkerPaged(t) defer testhelper.TeardownHTTP() page, err := pager.AllPages() testhelper.AssertNoErr(t, err) expected := []string{"aaa", "bbb", "ccc", "ddd", "eee", "fff", "ggg", "hhh", "iii"} actual, err := ExtractMarkerStrings(page) testhelper.AssertNoErr(t, err) testhelper.CheckDeepEquals(t, expected, actual) }
func TestGetAccount(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleGetAccountSuccessfully(t) expectedMetadata := map[string]string{"Subject": "books"} res := Get(fake.ServiceClient(), &GetOpts{}) th.AssertNoErr(t, res.Err) actualMetadata, _ := res.ExtractMetadata() th.CheckDeepEquals(t, expectedMetadata, actualMetadata) //headers, err := res.Extract() //th.AssertNoErr(t, err) }
func TestUpdateServer(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleServerUpdateSuccessfully(t) client := client.ServiceClient() actual, err := Update(client, "1234asdf", UpdateOpts{Name: "new-name"}).Extract() if err != nil { t.Fatalf("Unexpected Update error: %v", err) } th.CheckDeepEquals(t, ServerDerp, *actual) }
func TestGetServer(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleServerGetSuccessfully(t) client := client.ServiceClient() actual, err := Get(client, "1234asdf").Extract() if err != nil { t.Fatalf("Unexpected Get error: %v", err) } th.CheckDeepEquals(t, ServerDerp, *actual) }
func TestCreate(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleCreateSuccessfully(t) serverId := "4d8c3732-a248-40ed-bebc-539a6ffd25c0" actual, err := Create(client.ServiceClient(), serverId, CreateOpts{ Device: "/dev/vdc", VolumeID: "a26887c6-c47b-4654-abb5-dfadf7d3f804", }).Extract() th.AssertNoErr(t, err) th.CheckDeepEquals(t, &CreatedVolumeAttachment, actual) }
func TestCreateServer(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleServerCreationSuccessfully(t, SingleServerBody) actual, err := Create(client.ServiceClient(), CreateOpts{ Name: "derp", ImageRef: "f90f6034-2570-4974-8351-6b49732ef2eb", FlavorRef: "1", }).Extract() th.AssertNoErr(t, err) th.CheckDeepEquals(t, ServerDerp, *actual) }
func TestRebuildServer(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleRebuildSuccessfully(t, GetOutput) opts := os.RebuildOpts{ Name: "new-name", AdminPass: "******", ImageID: "http://104.130.131.164:8774/fcad67a6189847c4aecfa3c81a05783b/images/f90f6034-2570-4974-8351-6b49732ef2eb", AccessIPv4: "1.2.3.4", } actual, err := Rebuild(client.ServiceClient(), "1234asdf", opts).Extract() th.AssertNoErr(t, err) th.CheckDeepEquals(t, &GophercloudServer, actual) }
func TestGetServer(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/servers/8c65cb68-0681-4c30-bc88-6b83a8a26aee", 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") fmt.Fprintf(w, GetOutput) }) actual, err := Get(client.ServiceClient(), "8c65cb68-0681-4c30-bc88-6b83a8a26aee").Extract() th.AssertNoErr(t, err) th.CheckDeepEquals(t, &GophercloudServer, actual) }