Make util/wsstream/stream_test.go not flaky

It's hard to manage connection buffers in a deterministic test, ensure
that the error is always consistent and the output is always a subset
of the input

pkg/util/wsstream/stream_test.go

@@ -110,28 +110,31 @@ func TestStreamSurvivesPanic(t *testing.T) {
 }
 
 func TestStreamClosedDuringRead(t *testing.T) {
-	ch := make(chan struct{})
+	for i := 0; i < 25; i++ {
-	input := "some random text"
+		ch := make(chan struct{})
-	errs := &errorReader{
+		input := "some random text"
-		reads: [][]byte{
+		errs := &errorReader{
-			[]byte("some random"),
+			reads: [][]byte{
-			[]byte(" text"),
+				[]byte("some random"),
-		},
+				[]byte(" text"),
-		err:   fmt.Errorf("stuff"),
+			},
-		pause: ch,
+			err:   fmt.Errorf("stuff"),
-	}
+			pause: ch,
-	r := NewReader(errs, false)
+		}
+		r := NewReader(errs, false)
 
-	data, err := readWebSocket(r, t, func(c *websocket.Conn) {
+		data, err := readWebSocket(r, t, func(c *websocket.Conn) {
-		c.Close()
+			c.Close()
-		time.Sleep(time.Millisecond)
+			close(ch)
-		close(ch)
+		})
-	})
+		// verify that the data returned by the server on an early close always has a specific error
-	if !reflect.DeepEqual(data, []byte(input)) {
+		if err == nil || !strings.Contains(err.Error(), "use of closed network connection") {
-		t.Errorf("unexpected server read: %v", data)
+			t.Fatal(err)
-	}
+		}
-	if err == nil || !strings.Contains(err.Error(), "use of closed network connection") {
+		// verify that the data returned is a strict subset of the input
-		t.Fatal(err)
+		if !bytes.HasPrefix([]byte(input), data) && len(data) != 0 {
+			t.Fatalf("unexpected server read: %q", string(data))
+		}
 	}
 }