| // 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 |
| // |
| // 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 httpreplay_test |
| |
| // import ( |
| // "bytes" |
| // "context" |
| // "encoding/json" |
| // "fmt" |
| // "io" |
| // "io/ioutil" |
| // "log" |
| // "net/http" |
| // "net/http/httptest" |
| // "os" |
| // "path/filepath" |
| // "testing" |
| // "time" |
| |
| // "cloud.google.com/go/httpreplay" |
| // "cloud.google.com/go/internal/testutil" |
| // "cloud.google.com/go/storage" |
| // "google.golang.org/api/option" |
| // ) |
| |
| // const ( |
| // compressedFile = "httpreplay_compressed.txt" |
| // uncompressedFile = "httpreplay_uncompressed.txt" |
| // ) |
| |
| // func TestIntegration_RecordAndReplay(t *testing.T) { |
| // httpreplay.DebugHeaders() |
| // if testing.Short() { |
| // t.Skip("Integration tests skipped in short mode") |
| // } |
| // replayFilename := tempFilename(t, "RecordAndReplay*.replay") |
| // defer os.Remove(replayFilename) |
| // projectID := testutil.ProjID() |
| // if projectID == "" { |
| // t.Skip("Need project ID. See CONTRIBUTING.md for details.") |
| // } |
| // ctx := context.Background() |
| // cleanup, err := setup(ctx) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // defer cleanup() |
| |
| // // Record. |
| // initial := time.Now() |
| // ibytes, err := json.Marshal(initial) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // rec, err := httpreplay.NewRecorder(replayFilename, ibytes) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // hc, err := rec.Client(ctx, option.WithTokenSource( |
| // testutil.TokenSource(ctx, storage.ScopeFullControl))) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // wanta, wantc := run(t, hc) |
| // testReadCRC(t, hc, "recording") |
| // if err := rec.Close(); err != nil { |
| // t.Fatalf("rec.Close: %v", err) |
| // } |
| |
| // // Replay. |
| // rep, err := httpreplay.NewReplayer(replayFilename) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // defer rep.Close() |
| // hc, err = rep.Client(ctx) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // gota, gotc := run(t, hc) |
| // testReadCRC(t, hc, "replaying") |
| |
| // if diff := testutil.Diff(gota, wanta); diff != "" { |
| // t.Error(diff) |
| // } |
| // if !bytes.Equal(gotc, wantc) { |
| // t.Errorf("got %q, want %q", gotc, wantc) |
| // } |
| // var gotInitial time.Time |
| // if err := json.Unmarshal(rep.Initial(), &gotInitial); err != nil { |
| // t.Fatal(err) |
| // } |
| // if !gotInitial.Equal(initial) { |
| // t.Errorf("initial: got %v, want %v", gotInitial, initial) |
| // } |
| // } |
| |
| // func setup(ctx context.Context) (cleanup func(), err error) { |
| // ts := testutil.TokenSource(ctx, storage.ScopeFullControl) |
| // client, err := storage.NewClient(ctx, option.WithTokenSource(ts)) |
| // if err != nil { |
| // return nil, err |
| // } |
| // bucket := testutil.ProjID() |
| |
| // // upload compressed object |
| // f1, err := os.Open(filepath.Join("internal", "testdata", "compressed.txt")) |
| // if err != nil { |
| // return nil, err |
| // } |
| // defer f1.Close() |
| // w := client.Bucket(bucket).Object(compressedFile).NewWriter(ctx) |
| // w.ContentEncoding = "gzip" |
| // w.ContentType = "text/plain" |
| // if _, err = io.Copy(w, f1); err != nil { |
| // return nil, err |
| // } |
| // if err := w.Close(); err != nil { |
| // return nil, err |
| // } |
| // // upload uncompressed object |
| // f2, err := os.Open(filepath.Join("internal", "testdata", "uncompressed.txt")) |
| // if err != nil { |
| // return nil, err |
| // } |
| // defer f2.Close() |
| // w = client.Bucket(testutil.ProjID()).Object(uncompressedFile).NewWriter(ctx) |
| // if _, err = io.Copy(w, f2); err != nil { |
| // return nil, err |
| // } |
| // if err := w.Close(); err != nil { |
| // return nil, err |
| // } |
| // return func() { |
| // client.Bucket(bucket).Object(compressedFile).Delete(ctx) |
| // client.Bucket(bucket).Object(uncompressedFile).Delete(ctx) |
| // client.Close() |
| // }, nil |
| // } |
| |
| // // TODO(jba): test errors |
| |
| // func run(t *testing.T, hc *http.Client) (*storage.BucketAttrs, []byte) { |
| // ctx := context.Background() |
| // client, err := storage.NewClient(ctx, option.WithHTTPClient(hc)) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // defer client.Close() |
| // b := client.Bucket(testutil.ProjID()) |
| // attrs, err := b.Attrs(ctx) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // obj := b.Object("replay-test") |
| // w := obj.NewWriter(ctx) |
| // data := []byte{150, 151, 152} |
| // if _, err := w.Write(data); err != nil { |
| // t.Fatal(err) |
| // } |
| // if err := w.Close(); err != nil { |
| // t.Fatal(err) |
| // } |
| |
| // r, err := obj.NewReader(ctx) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // defer r.Close() |
| // contents, err := ioutil.ReadAll(r) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| |
| // return attrs, contents |
| // } |
| |
| // func testReadCRC(t *testing.T, hc *http.Client, mode string) { |
| // ctx := context.Background() |
| // client, err := storage.NewClient(ctx, option.WithHTTPClient(hc)) |
| // if err != nil { |
| // t.Fatalf("%s: %v", mode, err) |
| // } |
| // defer client.Close() |
| |
| // bucket := testutil.ProjID() |
| // uncompressedObj := client.Bucket(bucket).Object(uncompressedFile) |
| // gzippedObj := client.Bucket(bucket).Object(compressedFile) |
| |
| // for _, test := range []struct { |
| // desc string |
| // obj *storage.ObjectHandle |
| // offset, length int64 |
| // readCompressed bool // don't decompress a gzipped file |
| |
| // wantErr bool |
| // wantLen int // length of contents |
| // }{ |
| // { |
| // desc: "uncompressed, entire file", |
| // obj: uncompressedObj, |
| // offset: 0, |
| // length: -1, |
| // readCompressed: false, |
| // wantLen: 179, |
| // }, |
| // { |
| // desc: "uncompressed, entire file, don't decompress", |
| // obj: uncompressedObj, |
| // offset: 0, |
| // length: -1, |
| // readCompressed: true, |
| // wantLen: 179, |
| // }, |
| // { |
| // desc: "uncompressed, suffix", |
| // obj: uncompressedObj, |
| // offset: 9, |
| // length: -1, |
| // readCompressed: false, |
| // wantLen: 170, |
| // }, |
| // { |
| // desc: "uncompressed, prefix", |
| // obj: uncompressedObj, |
| // offset: 0, |
| // length: 18, |
| // readCompressed: false, |
| // wantLen: 18, |
| // }, |
| // { |
| // // When a gzipped file is unzipped by GCS, we can't verify the checksum |
| // // because it was computed against the zipped contents. There is no |
| // // header that indicates that a gzipped file is being served unzipped. |
| // // But our CRC check only happens if there is a Content-Length header, |
| // // and that header is absent for this read. |
| // desc: "compressed, entire file, server unzips", |
| // obj: gzippedObj, |
| // offset: 0, |
| // length: -1, |
| // readCompressed: false, |
| // wantLen: 179, |
| // }, |
| // { |
| // // When we read a gzipped file uncompressed, it's like reading a regular file: |
| // // the served content and the CRC match. |
| // desc: "compressed, entire file, read compressed", |
| // obj: gzippedObj, |
| // offset: 0, |
| // length: -1, |
| // readCompressed: true, |
| // wantLen: 128, |
| // }, |
| // { |
| // desc: "compressed, partial, read compressed", |
| // obj: gzippedObj, |
| // offset: 1, |
| // length: 8, |
| // readCompressed: true, |
| // wantLen: 8, |
| // }, |
| // { |
| // desc: "uncompressed, HEAD", |
| // obj: uncompressedObj, |
| // offset: 0, |
| // length: 0, |
| // wantLen: 0, |
| // }, |
| // { |
| // desc: "compressed, HEAD", |
| // obj: gzippedObj, |
| // offset: 0, |
| // length: 0, |
| // wantLen: 0, |
| // }, |
| // } { |
| // obj := test.obj.ReadCompressed(test.readCompressed) |
| // r, err := obj.NewRangeReader(ctx, test.offset, test.length) |
| // if err != nil { |
| // if test.wantErr { |
| // continue |
| // } |
| // t.Errorf("%s: %s: %v", mode, test.desc, err) |
| // continue |
| // } |
| // data, err := ioutil.ReadAll(r) |
| // _ = r.Close() |
| // if err != nil { |
| // t.Errorf("%s: %s: %v", mode, test.desc, err) |
| // continue |
| // } |
| // if got, want := len(data), test.wantLen; got != want { |
| // t.Errorf("%s: %s: len: got %d, want %d", mode, test.desc, got, want) |
| // } |
| // } |
| // } |
| |
| // func TestRemoveAndClear(t *testing.T) { |
| // // Disable logging for this test, since it generates a lot. |
| // log.SetOutput(ioutil.Discard) |
| // srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { |
| // fmt.Fprintln(w, "LGTM") |
| // })) |
| // defer srv.Close() |
| |
| // replayFilename := tempFilename(t, "TestRemoveAndClear*.replay") |
| // defer os.Remove(replayFilename) |
| |
| // ctx := context.Background() |
| // // Record |
| // rec, err := httpreplay.NewRecorder(replayFilename, nil) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // rec.ClearHeaders("Clear") |
| // rec.RemoveRequestHeaders("Rem*") |
| // rec.ClearQueryParams("c") |
| // rec.RemoveQueryParams("r") |
| // hc, err := rec.Client(ctx, option.WithoutAuthentication()) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // query := "k=1&r=2&c=3" |
| // req, err := http.NewRequest("GET", srv.URL+"?"+query, nil) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // headers := map[string]string{"Keep": "ok", "Clear": "secret", "Remove": "bye"} |
| // for k, v := range headers { |
| // req.Header.Set(k, v) |
| // } |
| // if _, err := hc.Do(req); err != nil { |
| // t.Fatal(err) |
| // } |
| // if err := rec.Close(); err != nil { |
| // t.Fatal(err) |
| // } |
| |
| // // Replay |
| // // For both headers and query param: |
| // // - k or Keep must be present and identical |
| // // - c or Clear must be present, but can be different |
| // // - r or Remove can be anything |
| // for _, test := range []struct { |
| // query string |
| // headers map[string]string |
| // wantSuccess bool |
| // }{ |
| // {query, headers, true}, // same query string and headers |
| // {query, |
| // map[string]string{"Keep": "oops", "Clear": "secret", "Remove": "bye"}, |
| // false, // different Keep |
| // }, |
| // {query, map[string]string{}, false}, // missing Keep and Clear |
| // {query, map[string]string{"Keep": "ok"}, false}, // missing Clear |
| // {query, map[string]string{"Keep": "ok", "Clear": "secret"}, true}, // missing Remove is OK |
| // { |
| // query, |
| // map[string]string{"Keep": "ok", "Clear": "secret", "Remove": "whatev"}, |
| // true, |
| // }, // different Remove is OK |
| // {query, map[string]string{"Keep": "ok", "Clear": "diff"}, true}, // different Clear is OK |
| // {"", headers, false}, // no query string |
| // {"k=x&r=2&c=3", headers, false}, // different k |
| // {"r=2", headers, false}, // missing k and c |
| // {"k=1&r=2", headers, false}, // missing c |
| // {"k=1&c=3", headers, true}, // missing r is OK |
| // {"k=1&r=x&c=3", headers, true}, // different r is OK, |
| // {"k=1&r=2&c=x", headers, true}, // different clear is OK |
| // } { |
| // rep, err := httpreplay.NewReplayer(replayFilename) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // hc, err = rep.Client(ctx) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // url := srv.URL |
| // if test.query != "" { |
| // url += "?" + test.query |
| // } |
| // req, err = http.NewRequest("GET", url, nil) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // for k, v := range test.headers { |
| // req.Header.Set(k, v) |
| // } |
| // resp, err := hc.Do(req) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // rep.Close() |
| // if (resp.StatusCode == 200) != test.wantSuccess { |
| // t.Errorf("%q, %v: got %d, wanted success=%t", |
| // test.query, test.headers, resp.StatusCode, test.wantSuccess) |
| // } |
| // } |
| // } |
| |
| // func tempFilename(t *testing.T, pattern string) string { |
| // f, err := ioutil.TempFile("", pattern) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // filename := f.Name() |
| // if err := f.Close(); err != nil { |
| // t.Fatal(err) |
| // } |
| // return filename |
| // } |
