Function TestConnClosePropagation

conn_test.go:736–880

(t *testing.T)

}

func TestConnClosePropagation(t *testing.T) {
	t.Parallel()

	want := []byte("hello")
	keepWriting := func(c *websocket.Conn) <-chan error {
		return xsync.Go(func() error {
			for {
				err := c.Write(context.Background(), websocket.MessageText, want)
				if err != nil {
					return err
				}
			}
		})
	}
	keepReading := func(c *websocket.Conn) <-chan error {
		return xsync.Go(func() error {
			for {
				_, got, err := c.Read(context.Background())
				if err != nil {
					return err
				}
				if !bytes.Equal(want, got) {
					return fmt.Errorf("unexpected message: want %q, got %q", want, got)
				}
			}
		})
	}
	checkReadErr := func(t *testing.T, err error) {
		// Check read error (output depends on when read is called in relation to connection closure).
		var ce websocket.CloseError
		if errors.As(err, &ce) {
			assert.Equal(t, "", websocket.StatusNormalClosure, ce.Code)
		} else {
			assert.ErrorIs(t, net.ErrClosed, err)
		}
	}
	checkConnErrs := func(t *testing.T, conn ...*websocket.Conn) {
		for _, c := range conn {
			// Check write error.
			err := c.Write(context.Background(), websocket.MessageText, want)
			assert.ErrorIs(t, net.ErrClosed, err)

			_, _, err = c.Read(context.Background())
			checkReadErr(t, err)
		}
	}

	t.Run("CloseOtherSideDuringWrite", func(t *testing.T) {
		tt, this, other := newConnTest(t, nil, nil)

		_ = this.CloseRead(tt.ctx)
		thisWriteErr := keepWriting(this)

		_, got, err := other.Read(tt.ctx)
		assert.Success(t, err)
		assert.Equal(t, "msg", want, got)

		err = other.Close(websocket.StatusNormalClosure, "")