reader_test.go

package netargv

import (
	"bufio"
	"io"
	"reflect"
	"strings"
	"testing"
)

// =====================================================================
// helpers
// =====================================================================

func newBufReader(s string) *bufio.Reader {
	return bufio.NewReader(strings.NewReader(s))
}

func newReader(s string) *Reader {
	return NewReader(strings.NewReader(s))
}

// =====================================================================
// Tests for: parseLine — handshake messages
// =====================================================================

func TestParseLine_Hello_SingleVersion(t *testing.T) {
	msgType, args, flags, _, err := newReader("").parseLine("hello --version=0")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "hello" {
		t.Fatalf("expected hello, got %q", msgType)
	}
	if len(args) != 0 {
		t.Fatalf("expected no positional args, got %v", args)
	}
	if got := flags["version"]; !reflect.DeepEqual(got, []string{"0"}) {
		t.Fatalf("expected version=[0], got %v", got)
	}
}

func TestParseLine_Hello_MultipleVersions(t *testing.T) {
	msgType, _, flags, _, err := newReader("").parseLine("hello --version=0 --version=1")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "hello" {
		t.Fatalf("expected hello, got %q", msgType)
	}
	want := []string{"0", "1"}
	if !reflect.DeepEqual(flags["version"], want) {
		t.Fatalf("expected version=%v, got %v", want, flags["version"])
	}
}

func TestParseLine_Auth(t *testing.T) {
	msgType, args, flags, _, err := newReader("").parseLine("auth --token=7fo8sdafhsd89fasdj0sas")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "auth" {
		t.Fatalf("expected auth, got %q", msgType)
	}
	if len(args) != 0 {
		t.Fatalf("expected no positional args, got %v", args)
	}
	if got := flags["token"]; !reflect.DeepEqual(got, []string{"7fo8sdafhsd89fasdj0sas"}) {
		t.Fatalf("unexpected token flag: %v", got)
	}
}

func TestParseLine_About(t *testing.T) {
	msgType, args, flags, _, err := newReader("").parseLine("about --host=worker2.insights.com --slots=1024 --os=linux --arch=amd64")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "about" {
		t.Fatalf("expected about, got %q", msgType)
	}
	if len(args) != 0 {
		t.Fatalf("expected no positional args, got %v", args)
	}
	checks := map[string]string{
		"host":  "worker2.insights.com",
		"slots": "1024",
		"os":    "linux",
		"arch":  "amd64",
	}
	for k, v := range checks {
		if got := flags[k]; len(got) != 1 || got[0] != v {
			t.Fatalf("flag %q: expected [%s], got %v", k, v, got)
		}
	}
}

func TestParseLine_Support(t *testing.T) {
	msgType, args, flags, _, err := newReader("").parseLine("support --name=Report:AnnualSomething --cost=5")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "support" {
		t.Fatalf("expected support, got %q", msgType)
	}
	if len(args) != 0 {
		t.Fatalf("expected no positional args, got %v", args)
	}
	if got := flags["name"]; !reflect.DeepEqual(got, []string{"Report:AnnualSomething"}) {
		t.Fatalf("unexpected name flag: %v", got)
	}
	if got := flags["cost"]; !reflect.DeepEqual(got, []string{"5"}) {
		t.Fatalf("unexpected cost flag: %v", got)
	}
}

func TestParseLine_Ready(t *testing.T) {
	msgType, args, flags, _, err := newReader("").parseLine("ready")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "ready" {
		t.Fatalf("expected ready, got %q", msgType)
	}
	if len(args) != 0 {
		t.Fatalf("expected no positional args, got %v", args)
	}
	if len(flags) != 0 {
		t.Fatalf("expected no flags, got %v", flags)
	}
}

// =====================================================================
// Tests for: parseLine — work-dispatch messages
// =====================================================================

func TestParseLine_Work(t *testing.T) {
	msgType, args, flags, _, err := newReader("").parseLine("work --id=8d9fsajfidsa9f08dsa --job=Report:AnnualSomething --content-type=application/vnd.sqlite3")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "work" {
		t.Fatalf("expected work, got %q", msgType)
	}
	if len(args) != 0 {
		t.Fatalf("expected no positional args, got %v", args)
	}
	if got := flags["id"]; !reflect.DeepEqual(got, []string{"8d9fsajfidsa9f08dsa"}) {
		t.Fatalf("unexpected id flag: %v", got)
	}
	if got := flags["job"]; !reflect.DeepEqual(got, []string{"Report:AnnualSomething"}) {
		t.Fatalf("unexpected job flag: %v", got)
	}
	if got := flags["content-type"]; !reflect.DeepEqual(got, []string{"application/vnd.sqlite3"}) {
		t.Fatalf("unexpected content-type flag: %v", got)
	}
}

func TestParseLine_Accept(t *testing.T) {
	msgType, args, flags, _, err := newReader("").parseLine("accept --id=8d9fsajfidsa9f08dsa --remaining-slots=23")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "accept" {
		t.Fatalf("expected accept, got %q", msgType)
	}
	if len(args) != 0 {
		t.Fatalf("expected no positional args, got %v", args)
	}
	if got := flags["remaining-slots"]; !reflect.DeepEqual(got, []string{"23"}) {
		t.Fatalf("unexpected remaining-slots flag: %v", got)
	}
}

func TestParseLine_Reject_QuotedMessage(t *testing.T) {
	msgType, args, flags, _, err := newReader("").parseLine(`reject --message="Job not supported"`)
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "reject" {
		t.Fatalf("expected reject, got %q", msgType)
	}
	if len(args) != 0 {
		t.Fatalf("expected no positional args, got %v", args)
	}
	if got := flags["message"]; !reflect.DeepEqual(got, []string{"Job not supported"}) {
		t.Fatalf("unexpected message flag: %v", got)
	}
}

func TestParseLine_Fail_QuotedMessage(t *testing.T) {
	msgType, _, flags, _, err := newReader("").parseLine(`fail --message="Unsupported protocol version"`)
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "fail" {
		t.Fatalf("expected fail, got %q", msgType)
	}
	if got := flags["message"]; !reflect.DeepEqual(got, []string{"Unsupported protocol version"}) {
		t.Fatalf("unexpected message flag: %v", got)
	}
}

func TestParseLine_Progress(t *testing.T) {
	msgType, args, flags, _, err := newReader("").parseLine(`progress 20% --id=8d9fsajfidsa9f08dsa --message="Hard at work"`)
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "progress" {
		t.Fatalf("expected progress, got %q", msgType)
	}
	if !reflect.DeepEqual(args, []string{"20%"}) {
		t.Fatalf("expected args=[20%%], got %v", args)
	}
	if got := flags["message"]; !reflect.DeepEqual(got, []string{"Hard at work"}) {
		t.Fatalf("unexpected message flag: %v", got)
	}
}

func TestParseLine_Completed(t *testing.T) {
	msgType, args, flags, _, err := newReader("").parseLine("completed success --id=8d9fsajfidsa9f08dsa --duration=1200")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "completed" {
		t.Fatalf("expected completed, got %q", msgType)
	}
	if !reflect.DeepEqual(args, []string{"success"}) {
		t.Fatalf("expected args=[success], got %v", args)
	}
	if got := flags["duration"]; !reflect.DeepEqual(got, []string{"1200"}) {
		t.Fatalf("unexpected duration flag: %v", got)
	}
}

func TestParseLine_Status(t *testing.T) {
	msgType, args, flags, _, err := newReader("").parseLine("status --available-slots=12 --load=23% --uptime=12:43")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "status" {
		t.Fatalf("expected status, got %q", msgType)
	}
	if len(args) != 0 {
		t.Fatalf("expected no positional args, got %v", args)
	}
	if got := flags["available-slots"]; !reflect.DeepEqual(got, []string{"12"}) {
		t.Fatalf("unexpected available-slots flag: %v", got)
	}
	if got := flags["load"]; !reflect.DeepEqual(got, []string{"23%"}) {
		t.Fatalf("unexpected load flag: %v", got)
	}
	if got := flags["uptime"]; !reflect.DeepEqual(got, []string{"12:43"}) {
		t.Fatalf("unexpected uptime flag: %v", got)
	}
}

// =====================================================================
// Tests for: parseLine — edge cases
// =====================================================================

func TestParseLine_BooleanFlag(t *testing.T) {
	_, _, flags, _, err := newReader("").parseLine("cmd --force")
	if err != nil {
		t.Fatal(err)
	}
	if got := flags["force"]; !reflect.DeepEqual(got, []string{"true"}) {
		t.Fatalf("expected force=[true], got %v", got)
	}
}

func TestParseLine_SingleQuotedFlagValue(t *testing.T) {
	_, _, flags, _, err := newReader("").parseLine("cmd --message='hello world'")
	if err != nil {
		t.Fatal(err)
	}
	if got := flags["message"]; !reflect.DeepEqual(got, []string{"hello world"}) {
		t.Fatalf("unexpected message flag: %v", got)
	}
}

func TestParseLine_MessageTypePreservesCase(t *testing.T) {
	msgType, _, _, _, err := newReader("").parseLine("Hello --version=0")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "Hello" {
		t.Fatalf("expected Hello, got %q", msgType)
	}
}

func TestParseLine_EmptyLine(t *testing.T) {
	msgType, args, flags, payloadLen, err := newReader("").parseLine("")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "" || args != nil || flags != nil || payloadLen != 0 {
		t.Fatalf("expected all-empty results for blank line, got %q %v %v", msgType, args, flags)
	}
}

func TestParseLine_Authenticated(t *testing.T) {
	msgType, args, flags, _, err := newReader("").parseLine("authenticated")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "authenticated" {
		t.Fatalf("expected authenticated, got %q", msgType)
	}
	if len(args) != 0 {
		t.Fatalf("expected no args, got %v", args)
	}
	if len(flags) != 0 {
		t.Fatalf("expected no flags, got %v", flags)
	}
}

// =====================================================================
// Tests for: parseLine — payload length declaration
// =====================================================================

func TestParseLine_PayloadLength(t *testing.T) {
	msgType, args, flags, payloadLen, err := newReader("").parseLine("upload --name=script.sh -- 1024")
	if err != nil {
		t.Fatal(err)
	}
	if msgType != "upload" {
		t.Fatalf("expected upload, got %q", msgType)
	}
	if len(args) != 0 {
		t.Fatalf("expected no positional args, got %v", args)
	}
	if got := flags["name"]; !reflect.DeepEqual(got, []string{"script.sh"}) {
		t.Fatalf("unexpected name flag: %v", got)
	}
	if payloadLen != 1024 {
		t.Fatalf("expected payloadLen=1024, got %d", payloadLen)
	}
}

func TestParseLine_PayloadLengthZero(t *testing.T) {
	_, _, _, payloadLen, err := newReader("").parseLine("ping")
	if err != nil {
		t.Fatal(err)
	}
	if payloadLen != 0 {
		t.Fatalf("expected payloadLen=0, got %d", payloadLen)
	}
}

func TestParseLine_PayloadMissingCount(t *testing.T) {
	_, _, _, _, err := newReader("").parseLine("upload --name=x --")
	if err == nil {
		t.Fatal("expected error for -- without byte count")
	}
}

func TestParseLine_PayloadInvalidCount(t *testing.T) {
	_, _, _, _, err := newReader("").parseLine("upload --name=x -- abc")
	if err == nil {
		t.Fatal("expected error for non-integer byte count")
	}
}

// =====================================================================
// Tests for: readLogicalLine
// =====================================================================

func TestReadLogicalLine_SimpleLine(t *testing.T) {
	r := &Reader{src: newBufReader("hello --version=0\n")}
	got, err := r.readLogicalLine()
	if err != nil {
		t.Fatal(err)
	}
	if string(got) != "hello --version=0" {
		t.Fatalf("unexpected line: %q", got)
	}
}

func TestReadLogicalLine_StripsTrailingWhitespace(t *testing.T) {
	r := &Reader{src: newBufReader("  ready  \n")}
	got, err := r.readLogicalLine()
	if err != nil {
		t.Fatal(err)
	}
	if string(got) != "ready" {
		t.Fatalf("unexpected line: %q", got)
	}
}

func TestReadLogicalLine_CRLFStripped(t *testing.T) {
	r := &Reader{src: newBufReader("auth --token=abc\r\n")}
	got, err := r.readLogicalLine()
	if err != nil {
		t.Fatal(err)
	}
	if string(got) != "auth --token=abc" {
		t.Fatalf("unexpected line: %q", got)
	}
}

func TestReadLogicalLine_SingleContinuation(t *testing.T) {
	input := "hello --version=0 \\\n--version=1\n"
	r := &Reader{src: newBufReader(input)}
	got, err := r.readLogicalLine()
	if err != nil {
		t.Fatal(err)
	}
	want := "hello --version=0 --version=1"
	if string(got) != want {
		t.Fatalf("expected %q, got %q", want, got)
	}
}

func TestReadLogicalLine_MultipleContinuations(t *testing.T) {
	input := "work \\\n--id=abc \\\n--job=Foo\n"
	r := &Reader{src: newBufReader(input)}
	got, err := r.readLogicalLine()
	if err != nil {
		t.Fatal(err)
	}
	want := "work --id=abc --job=Foo"
	if string(got) != want {
		t.Fatalf("expected %q, got %q", want, got)
	}
}

func TestReadLogicalLine_EOFOnEmptyBuffer(t *testing.T) {
	r := &Reader{src: newBufReader("")}
	_, err := r.readLogicalLine()
	if err != io.EOF {
		t.Fatalf("expected io.EOF, got %v", err)
	}
}

func TestReadLogicalLine_EOFMidContinuation(t *testing.T) {
	// Backslash at the very end with no following newline.
	r := &Reader{src: newBufReader("hello \\\n")}
	_, err := r.readLogicalLine()
	if err != io.ErrUnexpectedEOF {
		t.Fatalf("expected io.ErrUnexpectedEOF, got %v", err)
	}
}