| // Copyright 2018 Google LLC |
| |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package metadata |
| |
| import ( |
| "context" |
| "encoding/json" |
| "fmt" |
| "net/http" |
| "net/http/httptest" |
| "net/url" |
| "reflect" |
| "strings" |
| "testing" |
| "time" |
| |
| "github.com/google/go-cmp/cmp" |
| ) |
| |
| func TestWatchMetadata(t *testing.T) { |
| etag1, etag2 := "foo", "bar" |
| var req int |
| et := time.Now().Add(10 * time.Second).Format(time.RFC3339) |
| ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { |
| if req == 0 { |
| w.Header().Set("etag", etag1) |
| } else { |
| w.Header().Set("etag", etag2) |
| } |
| fmt.Fprintf(w, `{"instance":{"attributes":{"enable-oslogin":"true","ssh-keys":"name:ssh-rsa [KEY] hostname\nname:ssh-rsa [KEY] hostname","windows-keys":"{}\n{\"expireOn\":\"%[1]s\",\"exponent\":\"exponent\",\"modulus\":\"modulus\",\"username\":\"username\"}\n{\"expireOn\":\"%[1]s\",\"exponent\":\"exponent\",\"modulus\":\"modulus\",\"username\":\"username\",\"addToAdministrators\":true}","wsfc-addrs":"foo"}}}`, et) |
| req++ |
| })) |
| defer ts.Close() |
| |
| client := &Client{ |
| metadataURL: ts.URL, |
| httpClient: &http.Client{ |
| Timeout: 1 * time.Second, |
| }, |
| } |
| |
| truebool := new(bool) |
| *truebool = true |
| want := Attributes{ |
| EnableOSLogin: truebool, |
| WSFCAddresses: "foo", |
| WindowsKeys: WindowsKeys{ |
| WindowsKey{Exponent: "exponent", UserName: "username", Modulus: "modulus", ExpireOn: et, AddToAdministrators: nil}, |
| WindowsKey{Exponent: "exponent", UserName: "username", Modulus: "modulus", ExpireOn: et, AddToAdministrators: func() *bool { ret := true; return &ret }()}, |
| }, |
| SSHKeys: []string{"name:ssh-rsa [KEY] hostname", "name:ssh-rsa [KEY] hostname"}, |
| DisableTelemetry: false, |
| } |
| for _, e := range []string{etag1, etag2} { |
| got, err := client.Watch(context.Background()) |
| if err != nil { |
| t.Fatalf("error running watchMetadata: %v", err) |
| } |
| |
| gotA := got.Instance.Attributes |
| if !reflect.DeepEqual(gotA, want) { |
| t.Fatalf("Did not parse expected metadata.\ngot:\n'%+v'\nwant:\n'%+v'", gotA, want) |
| } |
| |
| if client.etag != e { |
| t.Fatalf("etag not updated as expected (%q != %q)", client.etag, e) |
| } |
| } |
| } |
| |
| func TestBlockProjectKeys(t *testing.T) { |
| tests := []struct { |
| json string |
| res bool |
| }{ |
| { |
| `{"instance": {"attributes": {"ssh-keys": "name:ssh-rsa [KEY] hostname\nname:ssh-rsa [KEY] hostname"},"project": {"attributes": {"ssh-keys": "name:ssh-rsa [KEY] hostname\nname:ssh-rsa [KEY] hostname"}}}}`, |
| false, |
| }, |
| { |
| `{"instance": {"attributes": {"sshKeys": "name:ssh-rsa [KEY] hostname\nname:ssh-rsa [KEY] hostname"},"project": {"attributes": {"ssh-keys": "name:ssh-rsa [KEY] hostname\nname:ssh-rsa [KEY] hostname"}}}}`, |
| true, |
| }, |
| { |
| `{"instance": {"attributes": {"block-project-ssh-keys": "true", "ssh-keys": "name:ssh-rsa [KEY] hostname\nname:ssh-rsa [KEY] hostname"},"project": {"attributes": {"ssh-keys": "name:ssh-rsa [KEY] hostname\nname:ssh-rsa [KEY] hostname"}}}}`, |
| true, |
| }, |
| } |
| for _, test := range tests { |
| var md Descriptor |
| if err := json.Unmarshal([]byte(test.json), &md); err != nil { |
| t.Errorf("failed to unmarshal JSON: %v", err) |
| } |
| if md.Instance.Attributes.BlockProjectKeys != test.res { |
| t.Errorf("instance-level sshKeys didn't set block-project-keys (got %t expected %t)", md.Instance.Attributes.BlockProjectKeys, test.res) |
| } |
| } |
| } |
| |
| func TestGetKey(t *testing.T) { |
| var gotHeaders http.Header |
| var gotReqURI string |
| wantValue := "value" |
| handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { |
| gotHeaders = r.Header |
| gotReqURI = r.RequestURI |
| fmt.Fprint(w, wantValue) |
| }) |
| testsrv := httptest.NewServer(handler) |
| defer testsrv.Close() |
| |
| client := New() |
| client.metadataURL = testsrv.URL |
| |
| key := "key" |
| wantURI := "/" + key |
| headers := map[string]string{"key": "value"} |
| gotValue, err := client.GetKey(context.Background(), key, headers) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| headers["Metadata-Flavor"] = "Google" |
| for k, v := range headers { |
| if gotHeaders.Get(k) != v { |
| t.Fatalf("received headers does not contain all expected headers, want: %q, got: %q", headers, gotHeaders) |
| } |
| } |
| if wantValue != gotValue { |
| t.Errorf("did not get expected return value, got :%q, want: %q", gotValue, wantValue) |
| } |
| if gotReqURI != wantURI { |
| t.Errorf("did not get expected request uri, got :%q, want: %q", gotReqURI, wantURI) |
| } |
| } |
| |
| func TestGetKeyRecursive(t *testing.T) { |
| var gotReqURI string |
| wantValue := `{"ssh-keys":"name:ssh-rsa [KEY] instance1\nothername:ssh-rsa [KEY] instance2","block-project-ssh-keys":"false","other-metadata":"foo"}` |
| |
| handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { |
| gotReqURI = r.RequestURI |
| fmt.Fprint(w, wantValue) |
| }) |
| |
| testsrv := httptest.NewServer(handler) |
| defer testsrv.Close() |
| |
| client := New() |
| client.metadataURL = testsrv.URL |
| |
| key := "key" |
| wantURI := fmt.Sprintf("/%s?alt=json&recursive=true", key) |
| gotValue, err := client.GetKeyRecursive(context.Background(), key) |
| if err != nil { |
| t.Errorf("client.GetKeyRecursive(ctx, %s) failed unexpectedly with error: %v", key, err) |
| } |
| |
| if wantValue != gotValue { |
| t.Errorf("client.GetKeyRecursive(ctx, %s) = %q, want: %q", key, gotValue, wantValue) |
| } |
| if gotReqURI != wantURI { |
| t.Errorf("did not get expected request uri, got :%q, want: %q", gotReqURI, wantURI) |
| } |
| } |
| |
| func TestShouldRetry(t *testing.T) { |
| tests := []struct { |
| desc string |
| status int |
| err error |
| want bool |
| }{ |
| { |
| desc: "404_should_not_retry", |
| status: 404, |
| want: false, |
| err: nil, |
| }, |
| { |
| desc: "429_should_retry", |
| status: 429, |
| want: true, |
| err: nil, |
| }, |
| { |
| desc: "random_err_should_retry", |
| status: 200, |
| want: true, |
| err: fmt.Errorf("fake retriable error"), |
| }, |
| } |
| |
| for _, test := range tests { |
| t.Run(test.desc, func(t *testing.T) { |
| err := &MDSReqError{test.status, test.err} |
| if got := shouldRetry(err); got != test.want { |
| t.Errorf("shouldRetry(%+v) = %t, want %t", err, got, test.want) |
| } |
| }) |
| } |
| } |
| |
| func TestRetry(t *testing.T) { |
| want := "some-metadata" |
| ctr := 0 |
| retries := 3 |
| |
| ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { |
| if ctr == retries { |
| fmt.Fprint(w, want) |
| } else { |
| ctr++ |
| // 412 error code should be retried. |
| w.WriteHeader(412) |
| } |
| })) |
| defer ts.Close() |
| |
| client := &Client{ |
| metadataURL: ts.URL, |
| httpClient: &http.Client{ |
| Timeout: 1 * time.Second, |
| }, |
| } |
| |
| reqURL, err := url.JoinPath(ts.URL, "key") |
| if err != nil { |
| t.Fatalf("Failed to setup mock URL: %v", err) |
| } |
| req := requestConfig{baseURL: reqURL} |
| |
| got, err := client.retry(context.Background(), req) |
| if err != nil { |
| t.Errorf("retry(ctx, %+v) failed unexpectedly with error: %v", req, err) |
| } |
| if got != want { |
| t.Errorf("retry(ctx, %+v) = %s, want %s", req, got, want) |
| } |
| if ctr != retries { |
| t.Errorf("retry(ctx, %+v) retried %d times, should have returned after %d retries", req, ctr, retries) |
| } |
| } |
| |
| func TestRetryError(t *testing.T) { |
| ctx := context.Background() |
| ctr := make(map[string]int) |
| backoffAttempts = 5 |
| |
| ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { |
| if strings.Contains(r.URL.Path, "retry") { |
| // Retriable status code. |
| w.WriteHeader(412) |
| } else { |
| // Non-retriable status code. |
| w.WriteHeader(404) |
| } |
| ctr[r.URL.Path] = ctr[r.URL.Path] + 1 |
| })) |
| defer ts.Close() |
| |
| client := &Client{ |
| metadataURL: ts.URL, |
| httpClient: &http.Client{ |
| Timeout: 1 * time.Second, |
| }, |
| } |
| |
| tests := []struct { |
| desc string |
| mdsKey string |
| wantCtr int |
| }{ |
| { |
| desc: "retries_exhausted", |
| wantCtr: backoffAttempts, |
| mdsKey: "/retry", |
| }, |
| { |
| desc: "non_retriable_failure", |
| wantCtr: 1, |
| mdsKey: "/fail_fast", |
| }, |
| } |
| |
| for _, test := range tests { |
| t.Run(test.desc, func(t *testing.T) { |
| reqURL, err := url.JoinPath(ts.URL, test.mdsKey) |
| if err != nil { |
| t.Fatalf("Failed to setup mock URL: %v", err) |
| } |
| req := requestConfig{baseURL: reqURL} |
| |
| _, err = client.retry(ctx, req) |
| if err == nil { |
| t.Errorf("retry(ctx, %+v) succeeded, want error", req) |
| } |
| if ctr[test.mdsKey] != test.wantCtr { |
| t.Errorf("retry(ctx, %+v) retried %d times, should have returned after %d retries", req, ctr[test.mdsKey], test.wantCtr) |
| } |
| }) |
| } |
| } |
| |
| func TestVlanInterfaces(t *testing.T) { |
| vlan := ` |
| { |
| "0": { |
| "5": { |
| "ipv6": [ |
| "::0" |
| ], |
| "mac": "abcd_mac", |
| "parentInterface": "/computeMetadata/v1/instance/network-interfaces/0/", |
| "mtu": 1460, |
| "vlan": 5 |
| } |
| } |
| }` |
| |
| cfg := fmt.Sprintf(`{"instance": {"vlanNetworkInterfaces": %s}}`, vlan) |
| |
| want := map[int]map[int]VlanInterface{ |
| 0: { |
| 5: { |
| Mac: "abcd_mac", |
| ParentInterface: "/computeMetadata/v1/instance/network-interfaces/0/", |
| MTU: 1460, |
| Vlan: 5, |
| IPv6: []string{"::0"}, |
| }, |
| }, |
| } |
| |
| var md *Descriptor |
| if err := json.Unmarshal([]byte(cfg), &md); err != nil { |
| t.Fatalf("json.Unmarshal(%s, &md) failed unexpectedly with error: %v", cfg, err) |
| } |
| |
| if diff := cmp.Diff(want, md.Instance.VlanNetworkInterfaces); diff != "" { |
| t.Errorf("json.Unmarshal(%s, &md) returned unexpected diff (-want,+got):\n %s", cfg, diff) |
| } |
| } |
