go-trustlog/internal/helpers/tlv_test.go

package helpers_test

import (
	"bytes"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"go.yandata.net/wangsiyuan/go-trustlog/internal/helpers"
)

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

	r := bytes.NewReader([]byte{})
	reader := helpers.NewTLVReader(r)
	assert.NotNil(t, reader)
}

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

	var buf bytes.Buffer
	writer := helpers.NewTLVWriter(&buf)
	assert.NotNil(t, writer)
}

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

	tests := []struct {
		name    string
		value   []byte
		wantErr bool
	}{
		{
			name:    "normal field",
			value:   []byte("test"),
			wantErr: false,
		},
		{
			name:    "empty field",
			value:   []byte{},
			wantErr: false,
		},
		{
			name:    "large field",
			value:   make([]byte, 1000),
			wantErr: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			var buf bytes.Buffer
			writer := helpers.NewTLVWriter(&buf)
			err := writer.WriteField(tt.value)
			if tt.wantErr {
				require.Error(t, err)
			} else {
				require.NoError(t, err)
				if len(tt.value) > 0 {
					assert.Positive(t, buf.Len())
				}
			}
		})
	}
}

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

	var buf bytes.Buffer
	writer := helpers.NewTLVWriter(&buf)

	err := writer.WriteStringField("test")
	require.NoError(t, err)
	assert.Positive(t, buf.Len())
}

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

	tests := []struct {
		name    string
		setup   func() *helpers.TLVReader
		wantErr bool
	}{
		{
			name: "normal field",
			setup: func() *helpers.TLVReader {
				var buf bytes.Buffer
				writer := helpers.NewTLVWriter(&buf)
				_ = writer.WriteField([]byte("test"))
				return helpers.NewTLVReader(&buf)
			},
			wantErr: false,
		},
		{
			name: "empty field",
			setup: func() *helpers.TLVReader {
				var buf bytes.Buffer
				writer := helpers.NewTLVWriter(&buf)
				_ = writer.WriteField([]byte{})
				return helpers.NewTLVReader(&buf)
			},
			wantErr: false,
		},
		{
			name: "invalid data",
			setup: func() *helpers.TLVReader {
				return helpers.NewTLVReader(bytes.NewReader([]byte{0xff, 0xff}))
			},
			wantErr: true,
		},
		{
			name: "empty reader",
			setup: func() *helpers.TLVReader {
				return helpers.NewTLVReader(bytes.NewReader([]byte{}))
			},
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			reader := tt.setup()
			result, err := reader.ReadField()
			if tt.wantErr {
				assert.Error(t, err)
			} else {
				assert.NoError(t, err)
				// Empty field returns nil
				if tt.name == "empty field" {
					assert.Nil(t, result)
				} else {
					assert.NotNil(t, result)
				}
			}
		})
	}
}

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

	var buf bytes.Buffer
	writer := helpers.NewTLVWriter(&buf)
	err := writer.WriteStringField("test")
	require.NoError(t, err)

	reader := helpers.NewTLVReader(&buf)
	result, err := reader.ReadStringField()
	require.NoError(t, err)
	assert.Equal(t, "test", result)
}

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

	tests := []struct {
		name  string
		value []byte
	}{
		{
			name:  "normal",
			value: []byte("test"),
		},
		{
			name:  "empty",
			value: []byte{},
		},
		{
			name:  "large",
			value: make([]byte, 100),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			// Write
			var buf bytes.Buffer
			writer := helpers.NewTLVWriter(&buf)
			err := writer.WriteField(tt.value)
			require.NoError(t, err)

			// Read
			reader := helpers.NewTLVReader(&buf)
			result, err := reader.ReadField()
			require.NoError(t, err)

			// Verify
			// Empty byte slice returns nil from ReadField
			if len(tt.value) == 0 {
				assert.Nil(t, result)
			} else {
				assert.Equal(t, tt.value, result)
			}
		})
	}
}

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

	var buf bytes.Buffer
	writer := helpers.NewTLVWriter(&buf)

	// Write multiple fields
	fields := [][]byte{
		[]byte("field1"),
		[]byte("field2"),
		[]byte("field3"),
	}

	for _, field := range fields {
		err := writer.WriteField(field)
		require.NoError(t, err)
	}

	// Read multiple fields
	reader := helpers.NewTLVReader(&buf)
	for i, expected := range fields {
		result, err := reader.ReadField()
		require.NoError(t, err, "field %d", i)
		assert.Equal(t, expected, result, "field %d", i)
	}
}

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

	var buf bytes.Buffer
	writer := helpers.NewTLVWriter(&buf)

	original := "test string"
	err := writer.WriteStringField(original)
	require.NoError(t, err)

	reader := helpers.NewTLVReader(&buf)
	result, err := reader.ReadStringField()
	require.NoError(t, err)
	assert.Equal(t, original, result)
}

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

	var buf bytes.Buffer
	writer := helpers.NewTLVWriter(&buf)
	_ = writer.WriteField([]byte("test"))

	reader := helpers.NewTLVReader(&buf)
	_, err := reader.ReadField()
	require.NoError(t, err)

	// Try to read beyond EOF - this will fail when trying to read varint length
	_, err = reader.ReadField()
	require.Error(t, err)
	// Error could be EOF or other read error
	assert.Contains(t, err.Error(), "failed to read")
}