mirror of
https://github.com/kiddin9/op-packages.git
synced 2026-11-17 05:53:03 +08:00
329 lines
11 KiB
Go
329 lines
11 KiB
Go
package control
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/matthewlu070111/smart-srun/core/internal/domain"
|
|
)
|
|
|
|
// dribbleReader hands out at most n bytes per Read, so a frame arrives split
|
|
// across many reads the way it does on a real socket.
|
|
type dribbleReader struct {
|
|
data []byte
|
|
chunk int
|
|
}
|
|
|
|
func (d *dribbleReader) Read(p []byte) (int, error) {
|
|
if len(d.data) == 0 {
|
|
return 0, io.EOF
|
|
}
|
|
size := min(min(d.chunk, len(p)), len(d.data))
|
|
copy(p, d.data[:size])
|
|
d.data = d.data[size:]
|
|
return size, nil
|
|
}
|
|
|
|
func validRequestLine(t *testing.T, method string, params any) []byte {
|
|
t.Helper()
|
|
request := map[string]any{
|
|
"rpc_version": Version,
|
|
"request_id": "req-1",
|
|
"method": method,
|
|
}
|
|
if params != nil {
|
|
request["params"] = params
|
|
}
|
|
encoded, err := json.Marshal(request)
|
|
if err != nil {
|
|
t.Fatalf("marshal: %v", err)
|
|
}
|
|
return append(encoded, '\n')
|
|
}
|
|
|
|
// T38 -- a request split across reads is one request, not a parse error.
|
|
func TestReadRequestReassemblesPartialFrames(t *testing.T) {
|
|
line := validRequestLine(t, "status.get", nil)
|
|
|
|
for _, chunk := range []int{1, 3, 7, len(line) - 1} {
|
|
reader := bufio.NewReaderSize(&dribbleReader{data: line, chunk: chunk}, 16)
|
|
request, err := ReadRequest(reader, MaxRequestBytes)
|
|
if err != nil {
|
|
t.Fatalf("chunk %d: %v", chunk, err)
|
|
}
|
|
if request.Method != "status.get" || request.RequestID != "req-1" {
|
|
t.Fatalf("chunk %d: %+v", chunk, request)
|
|
}
|
|
}
|
|
}
|
|
|
|
// A frame without its newline is incomplete. Parsing it anyway would act on a
|
|
// request the peer had not finished sending.
|
|
func TestReadRequestRejectsAFrameWithNoNewline(t *testing.T) {
|
|
line := bytes.TrimRight(validRequestLine(t, "status.get", nil), "\n")
|
|
reader := bufio.NewReader(bytes.NewReader(line))
|
|
|
|
_, err := ReadRequest(reader, MaxRequestBytes)
|
|
if err == nil {
|
|
t.Fatal("a request with no newline was accepted")
|
|
}
|
|
if !strings.Contains(err.Error(), "换行") {
|
|
t.Fatalf("error %q does not explain the framing rule", err)
|
|
}
|
|
}
|
|
|
|
// A peer that connects and leaves is not an error to report: nobody is waiting.
|
|
func TestReadRequestReportsACleanDisconnectDistinctly(t *testing.T) {
|
|
reader := bufio.NewReader(bytes.NewReader(nil))
|
|
_, err := ReadRequest(reader, MaxRequestBytes)
|
|
if !errors.Is(err, ErrClosed) {
|
|
t.Fatalf("err = %v, want ErrClosed", err)
|
|
}
|
|
}
|
|
|
|
// The limit stops the read. A peer that never sends a newline must not be able
|
|
// to make the daemon buffer an unbounded line first and check afterwards.
|
|
//
|
|
// The over-long frame is deliberately *valid* JSON: rejecting garbage proves
|
|
// nothing about the limit, since the parser would reject it anyway. The error
|
|
// has to be about the size.
|
|
func TestReadRequestEnforcesTheLimitWhileReading(t *testing.T) {
|
|
padding := strings.Repeat("x", 8192)
|
|
line := []byte(`{"rpc_version":1,"request_id":"r","method":"status.get",` +
|
|
`"params":{"note":"` + padding + `"}}` + "\n")
|
|
reader := bufio.NewReaderSize(bytes.NewReader(line), 64)
|
|
|
|
_, err := ReadRequest(reader, 1024)
|
|
if err == nil {
|
|
t.Fatal("an over-long request was accepted")
|
|
}
|
|
if !strings.Contains(err.Error(), "上限") {
|
|
t.Fatalf("error %q is not about the size limit; a well-formed frame "+
|
|
"over the limit must be refused for its size", err)
|
|
}
|
|
if code, _ := domain.CodeOf(err); code != domain.CodeInvalidArgument {
|
|
t.Fatalf("code = %q, want InvalidArgument", code)
|
|
}
|
|
|
|
// A peer that never sends a newline at all must also be stopped.
|
|
endless := bytes.Repeat([]byte("x"), 8192)
|
|
if _, err := ReadRequest(bufio.NewReaderSize(bytes.NewReader(endless), 64), 1024); err == nil {
|
|
t.Fatal("a frame with no newline and no end was accepted")
|
|
}
|
|
}
|
|
|
|
func TestDecodeRequestRejectsMalformedFrames(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
line string
|
|
code domain.ErrorCode
|
|
}{
|
|
{"future protocol version", `{"rpc_version":2,"request_id":"r","method":"status.get"}`,
|
|
domain.CodeUnsupportedCapability},
|
|
{"missing protocol version", `{"request_id":"r","method":"status.get"}`,
|
|
domain.CodeUnsupportedCapability},
|
|
{"unknown envelope field", `{"rpc_version":1,"request_id":"r","method":"status.get","as_root":true}`,
|
|
domain.CodeInvalidArgument},
|
|
{"empty request id", `{"rpc_version":1,"request_id":"","method":"status.get"}`,
|
|
domain.CodeInvalidArgument},
|
|
{"empty method", `{"rpc_version":1,"request_id":"r","method":""}`,
|
|
domain.CodeInvalidArgument},
|
|
{"two objects on one line", `{"rpc_version":1,"request_id":"r","method":"status.get"}{"rpc_version":1}`,
|
|
domain.CodeInvalidArgument},
|
|
{"not an object", `["status.get"]`, domain.CodeInvalidArgument},
|
|
{"not JSON", `status.get`, domain.CodeInvalidArgument},
|
|
{"empty line", ``, domain.CodeInvalidArgument},
|
|
}
|
|
|
|
for _, testCase := range cases {
|
|
t.Run(testCase.name, func(t *testing.T) {
|
|
_, err := DecodeRequest([]byte(testCase.line))
|
|
if err == nil {
|
|
t.Fatal("accepted")
|
|
}
|
|
code, ok := domain.CodeOf(err)
|
|
if !ok || code != testCase.code {
|
|
t.Fatalf("code = %q, want %q (err: %v)", code, testCase.code, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// The request id is echoed into every response and every log line about the
|
|
// call. An unbounded one lets a sender decide how large those become.
|
|
func TestDecodeRequestRejectsAnOverlongRequestID(t *testing.T) {
|
|
atTheLimit := `{"rpc_version":1,"request_id":"` + strings.Repeat("r", 128) +
|
|
`","method":"status.get"}`
|
|
if _, err := DecodeRequest([]byte(atTheLimit)); err != nil {
|
|
t.Fatalf("128 characters is the limit, not one over it: %v", err)
|
|
}
|
|
|
|
overIt := `{"rpc_version":1,"request_id":"` + strings.Repeat("r", 129) +
|
|
`","method":"status.get"}`
|
|
if _, err := DecodeRequest([]byte(overIt)); err == nil {
|
|
t.Fatal("a 129-character request id was accepted")
|
|
}
|
|
}
|
|
|
|
type brokenReader struct{}
|
|
|
|
func (brokenReader) Read([]byte) (int, error) {
|
|
return 0, errors.New("read unix @->/var/run: connection reset by peer")
|
|
}
|
|
|
|
// A connection that broke is not a malformed request. Dressing it up as one
|
|
// would blame the sender for the network dropping under it.
|
|
func TestReadRequestPropagatesATransportError(t *testing.T) {
|
|
_, err := ReadRequest(bufio.NewReader(brokenReader{}), MaxRequestBytes)
|
|
if err == nil {
|
|
t.Fatal("a broken connection was read as a frame")
|
|
}
|
|
if errors.Is(err, ErrClosed) {
|
|
t.Fatal("a reset connection was reported as a clean disconnect")
|
|
}
|
|
if _, classified := domain.CodeOf(err); classified {
|
|
t.Fatalf("err = %v; a transport failure must reach the caller as itself, "+
|
|
"not as a protocol complaint", err)
|
|
}
|
|
}
|
|
|
|
func TestDecodeRequestRejectsInvalidUTF8(t *testing.T) {
|
|
line := []byte(`{"rpc_version":1,"request_id":"r","method":"status.get"}`)
|
|
line[20] = 0xff
|
|
if _, err := DecodeRequest(line); err == nil {
|
|
t.Fatal("invalid UTF-8 was accepted")
|
|
}
|
|
}
|
|
|
|
// A response must be exactly one line: a raw newline inside would desynchronise
|
|
// the peer, which reads until the next newline.
|
|
func TestWriteResponseNeverEmitsARawNewlineInsideTheFrame(t *testing.T) {
|
|
response, err := NewSuccess("req-1", map[string]string{
|
|
"message": "第一行\n第二行\r\n带制表符\t",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("NewSuccess: %v", err)
|
|
}
|
|
|
|
var buffer bytes.Buffer
|
|
if err := WriteResponse(&buffer, response); err != nil {
|
|
t.Fatalf("WriteResponse: %v", err)
|
|
}
|
|
frame := buffer.Bytes()
|
|
if bytes.Count(frame, []byte("\n")) != 1 || frame[len(frame)-1] != '\n' {
|
|
t.Fatalf("frame is not exactly one line: %q", frame)
|
|
}
|
|
|
|
var decoded Response
|
|
if err := json.Unmarshal(frame[:len(frame)-1], &decoded); err != nil {
|
|
t.Fatalf("frame does not parse: %v", err)
|
|
}
|
|
var payload map[string]string
|
|
if err := json.Unmarshal(decoded.Result, &payload); err != nil {
|
|
t.Fatalf("result does not parse: %v", err)
|
|
}
|
|
if payload["message"] != "第一行\n第二行\r\n带制表符\t" {
|
|
t.Fatalf("newlines did not survive escaping: %q", payload["message"])
|
|
}
|
|
}
|
|
|
|
// shortWriter accepts one byte per call, like a socket under pressure.
|
|
type shortWriter struct{ buffer bytes.Buffer }
|
|
|
|
func (w *shortWriter) Write(p []byte) (int, error) {
|
|
if len(p) == 0 {
|
|
return 0, nil
|
|
}
|
|
return w.buffer.Write(p[:1])
|
|
}
|
|
|
|
func TestWriteResponseCompletesShortWrites(t *testing.T) {
|
|
response, _ := NewSuccess("req-1", map[string]int{"count": 42})
|
|
writer := &shortWriter{}
|
|
|
|
if err := WriteResponse(writer, response); err != nil {
|
|
t.Fatalf("WriteResponse: %v", err)
|
|
}
|
|
frame := writer.buffer.Bytes()
|
|
if frame[len(frame)-1] != '\n' {
|
|
t.Fatalf("frame was truncated by short writes: %q", frame)
|
|
}
|
|
var decoded Response
|
|
if err := json.Unmarshal(frame[:len(frame)-1], &decoded); err != nil {
|
|
t.Fatalf("frame does not parse: %v", err)
|
|
}
|
|
}
|
|
|
|
// An over-sized result becomes an error response, not a truncated one: half a
|
|
// JSON object would be read by the peer as a complete answer.
|
|
func TestWriteResponseReplacesAnOversizedResultWithAnError(t *testing.T) {
|
|
response, err := NewSuccess("req-1", strings.Repeat("x", MaxResponseBytes))
|
|
if err != nil {
|
|
t.Fatalf("NewSuccess: %v", err)
|
|
}
|
|
|
|
var buffer bytes.Buffer
|
|
if err := WriteResponse(&buffer, response); err != nil {
|
|
t.Fatalf("WriteResponse: %v", err)
|
|
}
|
|
if buffer.Len() > MaxResponseBytes {
|
|
t.Fatalf("frame is %d bytes, over the %d limit", buffer.Len(), MaxResponseBytes)
|
|
}
|
|
|
|
var decoded Response
|
|
if err := json.Unmarshal(bytes.TrimRight(buffer.Bytes(), "\n"), &decoded); err != nil {
|
|
t.Fatalf("frame does not parse: %v", err)
|
|
}
|
|
if decoded.OK {
|
|
t.Fatal("an over-sized response was reported as a success")
|
|
}
|
|
if string(decoded.Result) != "null" {
|
|
t.Fatalf("result = %s, want null on a failure", decoded.Result)
|
|
}
|
|
}
|
|
|
|
// A Result holding bytes that are not JSON cannot be marshalled. What goes out
|
|
// still has to be a complete, parseable failure the caller can match to its
|
|
// request.
|
|
func TestWriteResponseReplacesAResponseItCannotMarshal(t *testing.T) {
|
|
unencodable := Response{
|
|
RPCVersion: Version,
|
|
RequestID: "req-1",
|
|
OK: true,
|
|
Result: json.RawMessage(`{"unterminated":`),
|
|
}
|
|
|
|
var buffer bytes.Buffer
|
|
if err := WriteResponse(&buffer, unencodable); err != nil {
|
|
t.Fatalf("WriteResponse: %v", err)
|
|
}
|
|
|
|
var decoded Response
|
|
if err := json.Unmarshal(bytes.TrimRight(buffer.Bytes(), "\n"), &decoded); err != nil {
|
|
t.Fatalf("the replacement frame does not parse: %v (%q)", err, buffer.Bytes())
|
|
}
|
|
if decoded.OK {
|
|
t.Fatal("a response that could not be encoded went out as a success")
|
|
}
|
|
if decoded.RequestID != "req-1" {
|
|
t.Fatalf("request_id = %q, want it echoed so the caller can match the failure",
|
|
decoded.RequestID)
|
|
}
|
|
}
|
|
|
|
type failingWriter struct{}
|
|
|
|
func (failingWriter) Write([]byte) (int, error) { return 0, errors.New("peer gone") }
|
|
|
|
func TestWriteResponseReportsAPeerThatDisappeared(t *testing.T) {
|
|
response, _ := NewSuccess("req-1", nil)
|
|
if err := WriteResponse(failingWriter{}, response); err == nil {
|
|
t.Fatal("writing to a dead peer reported success")
|
|
}
|
|
}
|