| // Copyright 2019 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 |
| // |
| // http://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 storage |
| |
| import ( |
| "context" |
| "fmt" |
| "net/http" |
| "net/url" |
| "strings" |
| "testing" |
| "time" |
| |
| "cloud.google.com/go/internal/testutil" |
| "github.com/google/go-cmp/cmp/cmpopts" |
| "google.golang.org/api/googleapi" |
| "google.golang.org/api/iterator" |
| ) |
| |
| func TestHMACKeyHandle_GetParsing(t *testing.T) { |
| mt := &mockTransport{} |
| client := mockClient(t, mt) |
| projectID := "hmackey-project-id" |
| ctx := context.Background() |
| |
| tests := []struct { |
| res string |
| want *HMACKey |
| wantErr string |
| }{ |
| { |
| res: fmt.Sprintf(` |
| { |
| "kind": "storage#hmacKeyMetadata", |
| "projectId":%q,"state":"ACTIVE", |
| "timeCreated": "2019-07-06T11:21:58+00:00", |
| "updated": "2019-07-06T11:22:18+00:00" |
| }`, projectID), |
| want: &HMACKey{ |
| State: Active, |
| ProjectID: projectID, |
| UpdatedTime: time.Date(2019, 07, 06, 11, 22, 18, 0, time.UTC), |
| CreatedTime: time.Date(2019, 07, 06, 11, 21, 58, 0, time.UTC), |
| }, |
| }, |
| { |
| res: fmt.Sprintf(` |
| { |
| "kind": "storage#hmacKeyMetadata", |
| "projectId":%q,"state":"ACTIVE", |
| "timeCreated": "2019-07-06T11:21:58+00:00", |
| "updated": "2019-07-06T11:22:18+00:00" |
| }`, projectID), |
| want: &HMACKey{ |
| State: Active, |
| ProjectID: projectID, |
| UpdatedTime: time.Date(2019, 07, 06, 11, 22, 18, 0, time.UTC), |
| CreatedTime: time.Date(2019, 07, 06, 11, 21, 58, 0, time.UTC), |
| }, |
| }, |
| { |
| res: `{}`, |
| // CreatedTime must be formatted in RFC 3339. |
| wantErr: `CreatedTime: parsing time "" as "2006-01-02T15:04:05Z07:00"`, |
| }, |
| { |
| res: `{"timeCreated": "2019-07-foo"}`, |
| // CreatedTime must be formatted in RFC 3339. |
| wantErr: `CreatedTime: parsing time "2019-07-foo" as "2006-01-02T15:04:05Z07:00"`, |
| }, |
| { |
| res: `{ |
| "kind": "storage#hmacKeyMetadata", |
| "state":"INACTIVE", |
| "timeCreated": "2019-07-06T11:21:58+00:00" |
| }`, |
| // UpdatedTime must be formatted in RFC 3339. |
| wantErr: `UpdatedTime: parsing time "" as "2006-01-02T15:04:05Z07:00"`, |
| }, |
| } |
| |
| for i, tt := range tests { |
| mt.addResult(&http.Response{ |
| ProtoMajor: 1, |
| ProtoMinor: 1, |
| ContentLength: int64(len(tt.res)), |
| Status: "OK", |
| StatusCode: 200, |
| Body: bodyReader(tt.res), |
| }, nil) |
| hkh := client.HMACKeyHandle(projectID, "some-access-key-id") |
| got, err := hkh.Get(ctx) |
| if tt.wantErr != "" { |
| if err == nil || !strings.Contains(err.Error(), tt.wantErr) { |
| t.Errorf("#%d: failed to match errors:\ngot: %q\nwant: %q", i, err, tt.wantErr) |
| } |
| if got != nil { |
| t.Errorf("#%d: unexpectedly got a non-nil result: %#v\n", i, got) |
| } |
| continue |
| } |
| |
| if err != nil { |
| t.Errorf("#%d: got an unexpected error: %v", i, err) |
| continue |
| } |
| |
| if diff := testutil.Diff(got, tt.want); diff != "" { |
| t.Errorf("#%d: got - want +\n\n%s", i, diff) |
| } |
| } |
| } |
| |
| func TestHMACKeyHandle_Get_NotFound(t *testing.T) { |
| mt := &mockTransport{} |
| client := mockClient(t, mt) |
| ctx := context.Background() |
| |
| mt.addResult(&http.Response{ |
| ProtoMajor: 2, |
| ProtoMinor: 0, |
| Status: "OK", |
| StatusCode: http.StatusNotFound, |
| Body: bodyReader("Access ID not found in project"), |
| }, nil) |
| |
| hkh := client.HMACKeyHandle("project-id", "some-access-key-id") |
| _, gotErr := hkh.Get(ctx) |
| |
| wantErr := &googleapi.Error{ |
| Body: "Access ID not found in project", |
| Code: http.StatusNotFound, |
| Message: "", |
| } |
| if diff := testutil.Diff(gotErr, wantErr, cmpopts.IgnoreUnexported(googleapi.Error{})); diff != "" { |
| t.Fatalf("Error mismatch, got - want +\n%s", diff) |
| } |
| } |
| |
| func TestHMACKeyHandle_Delete(t *testing.T) { |
| mt := &mockTransport{} |
| client := mockClient(t, mt) |
| ctx := context.Background() |
| |
| tests := []struct { |
| statusCode int |
| msg string |
| wantErr error |
| }{ |
| { |
| statusCode: http.StatusBadRequest, |
| msg: "Cannot delete keys in 'ACTIVE' state", |
| wantErr: &googleapi.Error{ |
| Code: http.StatusBadRequest, Message: "Cannot delete keys in 'ACTIVE' state", |
| Body: `{"error":{"message":"Cannot delete keys in 'ACTIVE' state"}}`, |
| }, |
| }, |
| { |
| statusCode: http.StatusNotFound, |
| msg: "random message", |
| wantErr: &googleapi.Error{ |
| Code: http.StatusNotFound, Message: "random message", |
| Body: `{"error":{"message":"random message"}}`, |
| }, |
| }, |
| { |
| statusCode: http.StatusNotFound, |
| msg: "Access ID not found in project", |
| wantErr: &googleapi.Error{ |
| Code: http.StatusNotFound, Message: "Access ID not found in project", |
| Body: `{"error":{"message":"Access ID not found in project"}}`, |
| }, |
| }, |
| } |
| |
| for i, tt := range tests { |
| mt.addResult(&http.Response{ |
| ProtoMajor: 2, |
| ProtoMinor: 0, |
| Status: tt.msg, |
| StatusCode: tt.statusCode, |
| Body: bodyReader(fmt.Sprintf(`{"error":{"message":%q}}`, tt.msg)), |
| }, nil) |
| |
| hkh := client.HMACKeyHandle("project", "access-key-id") |
| err := hkh.Delete(ctx) |
| |
| if diff := testutil.Diff(err, tt.wantErr, cmpopts.IgnoreUnexported(googleapi.Error{})); diff != "" { |
| t.Errorf("#%d: error mismatch got - want +\n%s", i, diff) |
| } |
| } |
| } |
| |
| func TestHMACKeyHandle_Create(t *testing.T) { |
| mt := &mockTransport{} |
| client := mockClient(t, mt) |
| projectID := "hmackey-project-id" |
| serviceAccountEmail := "service-account-email-1" |
| ctx := context.Background() |
| |
| tests := []struct { |
| res string |
| want *HMACKey |
| wantErr string |
| }{ |
| { |
| res: ` |
| { |
| "kind": "storage#hmackey", |
| "secret":"bGoa+V7g/yqDXvKRqq+JTFn4uQZbPiQJo4pf9RzJ", |
| "metadata": { |
| "projectId":"project-id","state":"ACTIVE", |
| "timeCreated": "2019-07-06T11:21:58+00:00", |
| "updated": "2019-07-06T11:22:18+00:00" |
| } |
| }`, |
| want: &HMACKey{ |
| Secret: "bGoa+V7g/yqDXvKRqq+JTFn4uQZbPiQJo4pf9RzJ", |
| State: Active, |
| ProjectID: "project-id", |
| UpdatedTime: time.Date(2019, 07, 06, 11, 22, 18, 0, time.UTC), |
| CreatedTime: time.Date(2019, 07, 06, 11, 21, 58, 0, time.UTC), |
| }, |
| }, |
| { |
| res: `{}`, |
| wantErr: "Metadata cannot be nil", |
| }, |
| { |
| res: `{"metadata":{}}`, |
| // CreatedTime must be non-empty and it must formatted in RFC 3339. |
| wantErr: `CreatedTime: parsing time "" as "2006-01-02T15:04:05Z07:00"`, |
| }, |
| { |
| res: `{"metadata":{"timeCreated": "2019-07-foo"}}`, |
| // CreatedTime must be formatted in RFC 3339. |
| wantErr: `CreatedTime: parsing time "2019-07-foo" as "2006-01-02T15:04:05Z07:00"`, |
| }, |
| { |
| res: `{ |
| "kind": "storage#hmackey", |
| "secret":"bGoa+V7g/yqDXvKRqq+JTFn4uQZbPiQJo4pf9RzJ", |
| "metadata":{ |
| "kind": "storage#hmacKeyMetadata", |
| "state":"ACTIVE", |
| "timeCreated": "2019-07-06T12:11:33+00:00", |
| "projectId": "project-id", |
| "updated": "" |
| } |
| }`, |
| // ONLY during creation is it okay for UpdatedTime to not be set. |
| want: &HMACKey{ |
| Secret: "bGoa+V7g/yqDXvKRqq+JTFn4uQZbPiQJo4pf9RzJ", |
| State: Active, |
| ProjectID: "project-id", |
| CreatedTime: time.Date(2019, 07, 06, 12, 11, 33, 0, time.UTC), |
| }, |
| }, |
| } |
| |
| for i, tt := range tests { |
| mt.addResult(&http.Response{ |
| ProtoMajor: 1, |
| ProtoMinor: 1, |
| ContentLength: int64(len(tt.res)), |
| Status: "OK", |
| StatusCode: 200, |
| Body: bodyReader(tt.res), |
| }, nil) |
| got, err := client.CreateHMACKey(ctx, projectID, serviceAccountEmail) |
| if tt.wantErr != "" { |
| if err == nil || !strings.Contains(err.Error(), tt.wantErr) { |
| t.Errorf("#%d: failed to match errors:\ngot: %q\nwant: %q", i, err, tt.wantErr) |
| } |
| if got != nil { |
| t.Errorf("#%d: unexpectedly got a non-nil result: %#v\n", i, got) |
| } |
| continue |
| } |
| |
| if err != nil { |
| t.Errorf("#%d: got an unexpected error: %v", i, err) |
| continue |
| } |
| |
| if diff := testutil.Diff(got, tt.want); diff != "" { |
| t.Errorf("#%d: got - want +\n\n%s", i, diff) |
| } |
| } |
| |
| // Lastly ensure that a blank service account will return an error. |
| mt.addResult(&http.Response{ |
| ProtoMajor: 1, |
| ProtoMinor: 1, |
| Status: "OK", |
| StatusCode: 200, |
| Body: bodyReader("{}"), |
| }, nil) |
| hk, err := client.CreateHMACKey(ctx, projectID, "") |
| if err == nil { |
| t.Fatal("Unexpectedly succeeded in creating a key using a blank service account email") |
| } |
| if !strings.Contains(err.Error(), "non-blank service account email") { |
| t.Fatalf("Expected an error about a non-blank service account email: %v", err) |
| } |
| if hk != nil { |
| t.Fatalf("Unexpectedly got back a created HMACKey: %#v", hk) |
| } |
| } |
| |
| func TestHMACKey_UpdateState(t *testing.T) { |
| // This test ensures that updating the state can only |
| // happen with either of Active or Inactive. |
| |
| mt := &mockTransport{} |
| client := mockClient(t, mt) |
| projectID := "hmackey-project-id" |
| ctx := context.Background() |
| |
| hkh := client.HMACKeyHandle(projectID, "some-access-id") |
| |
| // 1. Ensure that invalid states are NOT accepted for an Update. |
| invalidStates := []HMACState{"", Deleted, "active", "inactive", "foo_bar"} |
| for _, invalidState := range invalidStates { |
| t.Run("invalid-"+string(invalidState), func(t *testing.T) { |
| _, err := hkh.Update(ctx, HMACKeyAttrsToUpdate{ |
| State: invalidState, |
| }) |
| if err == nil { |
| t.Fatal("Unexpectedly succeeded") |
| } |
| invalidStateMsg := fmt.Sprintf(`storage: invalid state %q for update, must be either "ACTIVE" or "INACTIVE"`, invalidState) |
| if err.Error() != invalidStateMsg { |
| t.Fatalf("Mismatched error: got: %q\nwant: %q", err, invalidStateMsg) |
| } |
| }) |
| } |
| |
| // 2. Ensure that valid states for Update are accepted. |
| validStates := []HMACState{Active, Inactive} |
| for _, validState := range validStates { |
| t.Run("valid-"+string(validState), func(t *testing.T) { |
| resBody := fmt.Sprintf(`{ |
| "kind": "storage#hmacKeyMetadata", |
| "state":%q, |
| "timeCreated": "2019-07-11T12:11:33+00:00", |
| "projectId": "project-id", |
| "updated": "2019-07-11T12:13:33+00:00" |
| }`, validState) |
| mt.addResult(&http.Response{ |
| ProtoMajor: 1, |
| ProtoMinor: 1, |
| ContentLength: int64(len(resBody)), |
| Status: "OK", |
| StatusCode: 200, |
| Body: bodyReader(resBody), |
| }, nil) |
| |
| hu, err := hkh.Update(ctx, HMACKeyAttrsToUpdate{ |
| State: validState, |
| }) |
| if err != nil { |
| t.Fatalf("Unexpected failure: %v", err) |
| } |
| if hu.State != validState { |
| t.Fatalf("Unexpected updated state %q, expected %q", hu.State, validState) |
| } |
| }) |
| } |
| } |
| |
| func TestHMACKey_ListFull(t *testing.T) { |
| mt := &mockTransport{} |
| client := mockClient(t, mt) |
| projectID := "hmackey-project-id" |
| ctx := context.Background() |
| |
| maxPages := 2 |
| page := 0 |
| mockResponse := func() { |
| defer func() { |
| page++ |
| }() |
| |
| var body string |
| if page >= maxPages { |
| body = `{"kind":"storage#hmacKeysMetadata","items":[]}` |
| } else { |
| offset := page * 2 |
| body = fmt.Sprintf(` |
| { |
| "kind": "storage#hmacKeysMetadata", |
| "items": [{ |
| "accessId": "accessid-%d", |
| "timeCreated": "2019-08-05T12:11:10+00:00", |
| "state": "ACTIVE" |
| }, { |
| "accessId": "accessid-%d", |
| "timeCreated": "2019-08-05T13:12:11+00:00", |
| "state": "INACTIVE" |
| }], |
| "nextPageToken": "pageToken" |
| }`, offset+1, offset+2) |
| } |
| |
| mt.addResult(&http.Response{ |
| ProtoMajor: 2, |
| ProtoMinor: 0, |
| Status: "OK", |
| StatusCode: 200, |
| Body: bodyReader(body), |
| }, nil) |
| } |
| |
| iter := client.ListHMACKeys(ctx, projectID) |
| |
| var gotKeys []*HMACKey |
| for { |
| mockResponse() |
| key, err := iter.Next() |
| if err == iterator.Done { |
| break |
| } |
| if err != nil { |
| t.Fatalf("Unexpected error: %v", err) |
| } |
| gotKeys = append(gotKeys, key) |
| } |
| |
| wantKeys := []*HMACKey{ |
| { |
| AccessID: "accessid-1", |
| CreatedTime: time.Date(2019, time.August, 5, 12, 11, 10, 0, time.UTC), |
| State: Active, |
| }, |
| { |
| AccessID: "accessid-2", |
| CreatedTime: time.Date(2019, time.August, 5, 13, 12, 11, 0, time.UTC), |
| State: Inactive, |
| }, |
| { |
| AccessID: "accessid-3", |
| CreatedTime: time.Date(2019, time.August, 5, 12, 11, 10, 0, time.UTC), |
| State: Active, |
| }, |
| { |
| AccessID: "accessid-4", |
| CreatedTime: time.Date(2019, time.August, 5, 13, 12, 11, 0, time.UTC), |
| State: Inactive, |
| }, |
| } |
| |
| if diff := testutil.Diff(gotKeys, wantKeys); diff != "" { |
| t.Fatalf("Response mismatch: got - want +\n%s", diff) |
| } |
| } |
| |
| func TestHMACKey_List_Options(t *testing.T) { |
| mt := &mockTransport{} |
| client := mockClient(t, mt) |
| projectID := "hmackey-project-id" |
| |
| // Our goal is just to examine the issued HTTP request's URL's |
| // Path and Query to ensure that we have the appropriate paramters. |
| tests := []struct { |
| name string |
| opts []HMACKeyOption |
| wantQuery url.Values |
| }{ |
| { |
| name: "defaults", |
| wantQuery: url.Values{ |
| "alt": {"json"}, |
| "prettyPrint": {"false"}, |
| }, |
| }, |
| { |
| name: "show deleted keys", |
| opts: []HMACKeyOption{ShowDeletedHMACKeys()}, |
| wantQuery: url.Values{"alt": {"json"}, "prettyPrint": {"false"}, "showDeletedKeys": {"true"}}, |
| }, |
| { |
| name: "for service account", |
| opts: []HMACKeyOption{ForHMACKeyServiceAccountEmail("foo@example.org")}, |
| wantQuery: url.Values{ |
| "alt": {"json"}, |
| "prettyPrint": {"false"}, |
| "serviceAccountEmail": {"foo@example.org"}, |
| }, |
| }, |
| { |
| name: "for userProjectID", |
| opts: []HMACKeyOption{UserProjectForHMACKeys("project-x")}, |
| wantQuery: url.Values{ |
| "alt": {"json"}, |
| "prettyPrint": {"false"}, |
| "userProject": {"project-x"}, |
| }, |
| }, |
| { |
| name: "all options", |
| opts: []HMACKeyOption{ |
| ForHMACKeyServiceAccountEmail("foo@example.org"), |
| UserProjectForHMACKeys("project-x"), |
| ShowDeletedHMACKeys(), |
| }, |
| wantQuery: url.Values{ |
| "alt": {"json"}, |
| "prettyPrint": {"false"}, |
| "serviceAccountEmail": {"foo@example.org"}, |
| "showDeletedKeys": {"true"}, |
| "userProject": {"project-x"}, |
| }, |
| }, |
| } |
| |
| for _, tt := range tests { |
| t.Run(tt.name, func(t *testing.T) { |
| body := `{"kind":"storage#hmacKeysMetadata","items":[]}` |
| mt.addResult(&http.Response{ |
| ProtoMajor: 2, |
| ProtoMinor: 0, |
| ContentLength: int64(len(body)), |
| Status: "OK", |
| StatusCode: 200, |
| Body: bodyReader(body), |
| }, nil) |
| ctx, cancel := context.WithCancel(context.Background()) |
| iter := client.ListHMACKeys(ctx, projectID, tt.opts...) |
| _, _ = iter.Next() |
| cancel() |
| |
| gotQuery := mt.gotReq.URL.Query() |
| if diff := testutil.Diff(gotQuery, tt.wantQuery); diff != "" { |
| t.Errorf("Query mismatch: got - want +\n%s", diff) |
| } |
| }) |
| } |
| } |
