| // Copyright 2020 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package main |
| |
| import ( |
| "bytes" |
| "io" |
| "strings" |
| "testing" |
| "testing/iotest" |
| |
| "github.com/google/go-cmp/cmp" |
| ) |
| |
| func TestLimitedWriter(t *testing.T) { |
| cases := []struct { |
| desc string |
| lw *limitedWriter |
| in []byte |
| want []byte |
| wantN int64 |
| wantRemaining int64 |
| err error |
| }{ |
| { |
| desc: "simple", |
| lw: &limitedWriter{dst: &bytes.Buffer{}, n: 10}, |
| in: []byte("hi"), |
| want: []byte("hi"), |
| wantN: 2, |
| wantRemaining: 8, |
| }, |
| { |
| desc: "writing nothing", |
| lw: &limitedWriter{dst: &bytes.Buffer{}, n: 10}, |
| in: []byte(""), |
| want: []byte(""), |
| wantN: 0, |
| wantRemaining: 10, |
| }, |
| { |
| desc: "writing exactly enough", |
| lw: &limitedWriter{dst: &bytes.Buffer{}, n: 6}, |
| in: []byte("enough"), |
| want: []byte("enough"), |
| wantN: 6, |
| wantRemaining: 0, |
| err: nil, |
| }, |
| { |
| desc: "writing too much", |
| lw: &limitedWriter{dst: &bytes.Buffer{}, n: 10}, |
| in: []byte("this is much longer than 10"), |
| want: []byte("this is mu"), |
| wantN: 10, |
| wantRemaining: -1, |
| err: errTooMuchOutput, |
| }, |
| } |
| for _, c := range cases { |
| t.Run(c.desc, func(t *testing.T) { |
| n, err := io.Copy(c.lw, iotest.OneByteReader(bytes.NewReader(c.in))) |
| if err != c.err { |
| t.Errorf("c.lw.Write(%q) = %d, %q, wanted %d, %q", c.in, n, err, c.wantN, c.err) |
| } |
| if n != c.wantN { |
| t.Errorf("c.lw.Write(%q) = %d, %q, wanted %d, %q", c.in, n, err, c.wantN, c.err) |
| } |
| if c.lw.n != c.wantRemaining { |
| t.Errorf("c.lw.n = %d, wanted %d", c.lw.n, c.wantRemaining) |
| } |
| if string(c.lw.dst.Bytes()) != string(c.want) { |
| t.Errorf("c.lw.dst.Bytes() = %q, wanted %q", c.lw.dst.Bytes(), c.want) |
| } |
| }) |
| } |
| } |
| |
| func TestSwitchWriter(t *testing.T) { |
| cases := []struct { |
| desc string |
| sw *switchWriter |
| in []byte |
| want1 []byte |
| want2 []byte |
| wantN int64 |
| wantFound bool |
| err error |
| }{ |
| { |
| desc: "not found", |
| sw: &switchWriter{switchAfter: []byte("UNIQUE")}, |
| in: []byte("hi"), |
| want1: []byte("hi"), |
| want2: []byte(""), |
| wantN: 2, |
| wantFound: false, |
| }, |
| { |
| desc: "writing nothing", |
| sw: &switchWriter{switchAfter: []byte("UNIQUE")}, |
| in: []byte(""), |
| want1: []byte(""), |
| want2: []byte(""), |
| wantN: 0, |
| wantFound: false, |
| }, |
| { |
| desc: "writing exactly switchAfter", |
| sw: &switchWriter{switchAfter: []byte("UNIQUE")}, |
| in: []byte("UNIQUE"), |
| want1: []byte("UNIQUE"), |
| want2: []byte(""), |
| wantN: 6, |
| wantFound: true, |
| }, |
| { |
| desc: "writing before and after switchAfter", |
| sw: &switchWriter{switchAfter: []byte("UNIQUE")}, |
| in: []byte("this is before UNIQUE and this is after"), |
| want1: []byte("this is before UNIQUE"), |
| want2: []byte(" and this is after"), |
| wantN: 39, |
| wantFound: true, |
| }, |
| } |
| for _, c := range cases { |
| t.Run(c.desc, func(t *testing.T) { |
| dst1, dst2 := &bytes.Buffer{}, &bytes.Buffer{} |
| c.sw.dst1, c.sw.dst2 = dst1, dst2 |
| n, err := io.Copy(c.sw, iotest.OneByteReader(bytes.NewReader(c.in))) |
| if err != c.err { |
| t.Errorf("c.sw.Write(%q) = %d, %q, wanted %d, %q", c.in, n, err, c.wantN, c.err) |
| } |
| if n != c.wantN { |
| t.Errorf("c.sw.Write(%q) = %d, %q, wanted %d, %q", c.in, n, err, c.wantN, c.err) |
| } |
| if c.sw.found != c.wantFound { |
| t.Errorf("c.sw.found = %v, wanted %v", c.sw.found, c.wantFound) |
| } |
| if string(dst1.Bytes()) != string(c.want1) { |
| t.Errorf("dst1.Bytes() = %q, wanted %q", dst1.Bytes(), c.want1) |
| } |
| if string(dst2.Bytes()) != string(c.want2) { |
| t.Errorf("dst2.Bytes() = %q, wanted %q", dst2.Bytes(), c.want2) |
| } |
| }) |
| } |
| } |
| |
| func TestSwitchWriterMultipleWrites(t *testing.T) { |
| dst1, dst2 := &bytes.Buffer{}, &bytes.Buffer{} |
| sw := &switchWriter{ |
| dst1: dst1, |
| dst2: dst2, |
| switchAfter: []byte("GOPHER"), |
| } |
| n, err := io.Copy(sw, iotest.OneByteReader(strings.NewReader("this is before GO"))) |
| if err != nil || n != 17 { |
| t.Errorf("sw.Write(%q) = %d, %q, wanted %d, no error", "this is before GO", n, err, 17) |
| } |
| if sw.found { |
| t.Errorf("sw.found = %v, wanted %v", sw.found, false) |
| } |
| if string(dst1.Bytes()) != "this is before GO" { |
| t.Errorf("dst1.Bytes() = %q, wanted %q", dst1.Bytes(), "this is before GO") |
| } |
| if string(dst2.Bytes()) != "" { |
| t.Errorf("dst2.Bytes() = %q, wanted %q", dst2.Bytes(), "") |
| } |
| n, err = io.Copy(sw, iotest.OneByteReader(strings.NewReader("PHER and this is after"))) |
| if err != nil || n != 22 { |
| t.Errorf("sw.Write(%q) = %d, %q, wanted %d, no error", "this is before GO", n, err, 22) |
| } |
| if !sw.found { |
| t.Errorf("sw.found = %v, wanted %v", sw.found, true) |
| } |
| if string(dst1.Bytes()) != "this is before GOPHER" { |
| t.Errorf("dst1.Bytes() = %q, wanted %q", dst1.Bytes(), "this is before GOPHEr") |
| } |
| if string(dst2.Bytes()) != " and this is after" { |
| t.Errorf("dst2.Bytes() = %q, wanted %q", dst2.Bytes(), " and this is after") |
| } |
| } |
| |
| func TestParseDockerContainers(t *testing.T) { |
| cases := []struct { |
| desc string |
| output string |
| want []dockerContainer |
| wantErr bool |
| }{ |
| { |
| desc: "normal output (container per line)", |
| output: `{"Command":"\"/usr/local/bin/play…\"","CreatedAt":"2020-04-23 17:44:02 -0400 EDT","ID":"f7f170fde076","Image":"gcr.io/golang-org/playground-sandbox-gvisor:latest","Labels":"","LocalVolumes":"0","Mounts":"","Names":"play_run_a02cfe67","Networks":"none","Ports":"","RunningFor":"8 seconds ago","Size":"0B","Status":"Up 7 seconds"} |
| {"Command":"\"/usr/local/bin/play…\"","CreatedAt":"2020-04-23 17:44:02 -0400 EDT","ID":"af872e55a773","Image":"gcr.io/golang-org/playground-sandbox-gvisor:latest","Labels":"","LocalVolumes":"0","Mounts":"","Names":"play_run_0a69c3e8","Networks":"none","Ports":"","RunningFor":"8 seconds ago","Size":"0B","Status":"Up 7 seconds"}`, |
| want: []dockerContainer{ |
| {ID: "f7f170fde076", Image: "gcr.io/golang-org/playground-sandbox-gvisor:latest", Names: "play_run_a02cfe67"}, |
| {ID: "af872e55a773", Image: "gcr.io/golang-org/playground-sandbox-gvisor:latest", Names: "play_run_0a69c3e8"}, |
| }, |
| wantErr: false, |
| }, |
| { |
| desc: "empty output", |
| wantErr: false, |
| }, |
| { |
| desc: "malformatted output", |
| output: `xyzzy{}`, |
| wantErr: true, |
| }, |
| } |
| for _, tc := range cases { |
| t.Run(tc.desc, func(t *testing.T) { |
| cs, err := parseDockerContainers([]byte(tc.output)) |
| if (err != nil) != tc.wantErr { |
| t.Errorf("parseDockerContainers(_) = %v, %v, wantErr: %v", cs, err, tc.wantErr) |
| } |
| if diff := cmp.Diff(tc.want, cs); diff != "" { |
| t.Errorf("parseDockerContainers() mismatch (-want +got):\n%s", diff) |
| } |
| }) |
| } |
| } |
