encoder_test.go

// Copyright (c) 2025 Dell Inc. or its subsidiaries.  All rights reserved.
// Licensed to You under the Apache License, Version 2.0.   See the LICENSE file for more details.

package jsonstream_test

import (
	"bytes"
	"errors"
	"io"
	"testing"

	"github.com/sailfishdell/jsonstream"
)

const ExpectedError = "Expected error %v got %v"

type testTokenIterator struct {
	isClosed    bool
	count       int
	returns     []nextTokenOutput
	errForClose error
}

func (t *testTokenIterator) NextToken() (jsonstream.JSONPath, []byte, error) {
	if len(t.returns) == 0 || t.isClosed || t.count >= len(t.returns) {
		return jsonstream.JSONPath{}, nil, io.EOF
	}
	defer func() {
		t.count++
	}()
	return t.returns[t.count].Path, t.returns[t.count].Token, t.returns[t.count].Error
}

func (t *testTokenIterator) Close() error {
	t.isClosed = true
	return t.errForClose
}

type testFilter struct {
	parent jsonstream.TokenIterator
}

func (f *testFilter) Filter(iter jsonstream.TokenIterator) jsonstream.TokenIterator {
	f.parent = iter
	return f
}

func (*testFilter) NextToken() (jsonstream.JSONPath, []byte, error) {
	return jsonstream.JSONPath{}, nil, nil
}

func (*testFilter) Close() error {
	return nil
}

type errorWriter struct {
}

func (*errorWriter) Write([]byte) (n int, err error) {
	return 0, io.ErrClosedPipe
}

func TestChain(t *testing.T) {
	// Empty chain basically just shouldn't panic...
	filterFunc := jsonstream.Chain()
	iter := &testTokenIterator{}
	ret := filterFunc(iter)
	if ret != iter {
		t.Errorf("Empty Chain: Expected %v, got %v", iter, ret)
	}
	myFilter := &testFilter{}
	filterFunc = jsonstream.Chain(myFilter.Filter)
	ret = filterFunc(iter)
	if ret != myFilter {
		t.Errorf("Filter Chain: Expected %v, got %v returned from filterFunc", myFilter, ret)
	}
	if myFilter.parent != iter {
		t.Errorf("Filter Chain: Expected %v, got %v chain", iter, myFilter.parent)
	}
}

func TestWriterError(t *testing.T) {
	enc := jsonstream.NewEncoder(&errorWriter{})
	err := enc.EncodeOne(jsonstream.NewJSONPath([]byte(nil)), []byte(`"test"`))
	if err != io.ErrClosedPipe {
		t.Errorf(ExpectedError, io.ErrClosedPipe, err)
	}
}

func TestEncodingPathError(t *testing.T) {
	defer func() {
		if r := recover(); r == nil {
			t.Errorf("Expected panic")
		}
	}()
	enc := jsonstream.NewEncoder(bytes.NewBuffer(nil))
	_ = enc.EncodeOne(jsonstream.JSONPath{true}, []byte(`"test"`))
}

func TestEncode(t *testing.T) {
	buffer := bytes.NewBuffer(nil)
	enc := jsonstream.NewEncoder(buffer)
	iter := &testTokenIterator{}
	err := enc.Encode(iter)
	if err != nil {
		t.Errorf("Expected no error, got %v", err)
	}
	if !iter.isClosed {
		t.Errorf("Expected iterator to be closed")
	}
	// Error case
	iter.isClosed = false
	iter.returns = []nextTokenOutput{
		{Error: io.ErrUnexpectedEOF},
	}
	err = enc.Encode(iter)
	// Error should be wrapped...
	if !errors.Is(err, io.ErrUnexpectedEOF) {
		t.Errorf(ExpectedError, io.ErrUnexpectedEOF, err)
	}
	enc = jsonstream.NewEncoder(&errorWriter{})
	iter.isClosed = false
	iter.count = 0
	iter.returns = []nextTokenOutput{
		{Path: jsonstream.NewJSONPath("test"), Token: []byte(`"123"`)},
	}
	err = enc.Encode(iter)
	if !errors.Is(err, io.ErrClosedPipe) {
		t.Errorf(ExpectedError, io.ErrClosedPipe, err)
	}
}