generic_test.go

package testmark_test

import (
	"strings"
	"testing"

	testmark "github.com/warpfork/go-testmark/v2"
)

func TestNewHunkGeneric(t *testing.T) {
	// Test with string
	stringHunk := testmark.NewHunk("test1", "text", "Hello, World!")
	if stringHunk.Name() != "test1" {
		t.Errorf("expected name 'test1', got %q", stringHunk.Name())
	}
	if stringHunk.InfoString() != "text" {
		t.Errorf("expected info string 'text', got %q", stringHunk.InfoString())
	}
	if stringHunk.String() != "Hello, World!" {
		t.Errorf("expected body 'Hello, World!', got %q", stringHunk.String())
	}

	// Test with []byte
	byteData := []byte("Binary data \x00\x01\x02")
	byteHunk := testmark.NewHunk("test2", "binary", byteData)
	if byteHunk.Name() != "test2" {
		t.Errorf("expected name 'test2', got %q", byteHunk.Name())
	}
	if byteHunk.InfoString() != "binary" {
		t.Errorf("expected info string 'binary', got %q", byteHunk.InfoString())
	}
	if string(byteHunk.Body()) != string(byteData) {
		t.Errorf("expected body %v, got %v", byteData, byteHunk.Body())
	}

	// Test with io.Reader
	readerData := "Data from reader"
	reader := strings.NewReader(readerData)
	readerHunk := testmark.NewHunkFromReader("test3", "json", reader)
	if readerHunk.Name() != "test3" {
		t.Errorf("expected name 'test3', got %q", readerHunk.Name())
	}
	if readerHunk.InfoString() != "json" {
		t.Errorf("expected info string 'json', got %q", readerHunk.InfoString())
	}
	if readerHunk.String() != readerData {
		t.Errorf("expected body %q, got %q", readerData, readerHunk.String())
	}
}

func TestNewHunkLegacyCompatibility(t *testing.T) {
	// Test that legacy constructors still work
	stringHunk := testmark.NewHunkString("legacy1", "text", "legacy string")
	if stringHunk.String() != "legacy string" {
		t.Errorf("NewHunkString failed: got %q", stringHunk.String())
	}

	byteData := []byte("legacy bytes")
	byteHunk := testmark.NewHunkBytes("legacy2", "binary", byteData)
	if string(byteHunk.Body()) != string(byteData) {
		t.Errorf("NewHunkBytes failed: got %v", byteHunk.Body())
	}
}

func TestNewHunkGenericInDocument(t *testing.T) {
	// Test that generic constructor works with document patching
	doc := testmark.MustParseString(`# Test

[testmark]:# (original)
` + "```\noriginal content\n```" + `
`)

	// Patch with different body types
	stringPatch := testmark.NewHunk("original", "text", "string replacement")
	stringPatched := doc.Patch(stringPatch)
	if stringPatched.HunkByName("original").String() != "string replacement" {
		t.Error("String patch failed")
	}

	bytePatch := testmark.NewHunk("original", "binary", []byte("byte replacement"))
	bytePatched := doc.Patch(bytePatch)
	if bytePatched.HunkByName("original").String() != "byte replacement" {
		t.Error("Byte patch failed")
	}

	readerPatch := testmark.NewHunkFromReader("original", "json", strings.NewReader("reader replacement"))
	readerPatched := doc.Patch(readerPatch)
	if readerPatched.HunkByName("original").String() != "reader replacement" {
		t.Error("Reader patch failed")
	}
}

func TestNewHunkErrorHandling(t *testing.T) {
	// Test panic on empty name
	defer func() {
		if r := recover(); r == nil {
			t.Error("Expected panic for empty name")
		}
	}()
	testmark.NewHunk("", "", "content")
}

func TestNewHunkWithWhitespaceName(t *testing.T) {
	// Test panic on name with whitespace
	defer func() {
		if r := recover(); r == nil {
			t.Error("Expected panic for name with whitespace")
		}
	}()
	testmark.NewHunk("invalid name", "", "content")
}