searchreplace_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"
	"io"
	"testing"

	"github.com/sailfishdell/jsonstream"
)

const expectedNilToken = "Expected nil token got %#v"

func compareNextTokenOutput(t *testing.T, path jsonstream.JSONPath, tok []byte, err error) {
	t.Helper()
	compareNextTokenOutputWithExpectedPath(t, "/foo", path, tok, err)
}

func compareNextTokenOutputArray(t *testing.T, path jsonstream.JSONPath, tok []byte, err error) {
	t.Helper()
	compareNextTokenOutputWithExpectedPath(t, "/1", path, tok, err)
}

func compareNextTokenOutputWithExpectedPath(t *testing.T, expectedPath string, path jsonstream.JSONPath, tok []byte, err error) {
	t.Helper()
	compareNextTokenOutputWithPathAndToken(t, expectedPath, []byte(`"bar"`), path, tok, err)
}

func compareNextTokenOutputWithPathAndToken(t *testing.T, expectedPath string, expectedToken []byte,
	path jsonstream.JSONPath, tok []byte, err error) {
	t.Helper()
	if path.String() != expectedPath {
		t.Errorf("Expected %s got %s", expectedPath, path.String())
	}
	if !bytes.Equal(tok, expectedToken) {
		t.Errorf("Expected %s got %s", expectedToken, tok)
	}
	if err != nil {
		t.Errorf("Expected nil error got %v", err)
	}
}

func compareEOFCase(t *testing.T, path jsonstream.JSONPath, tok []byte, err error) {
	t.Helper()
	compareErrorCase(t, io.EOF, path, tok, err)
}

func compareErrorCase(t *testing.T, expectedError error, path jsonstream.JSONPath, tok []byte, err error) {
	t.Helper()
	if path.String() != "" {
		t.Errorf("Expected empty string got %s", path.String())
	}
	if tok != nil {
		t.Errorf(expectedNilToken, tok)
	}
	if err != expectedError {
		t.Errorf("Expected %v got %v", expectedError, err)
	}
}

func TestEmitOne(t *testing.T) {
	ti := jsonstream.EmitOne(jsonstream.NewJSONPath("foo"), []byte(`"bar"`))
	path, tok, err := ti.NextToken()
	compareNextTokenOutput(t, path, tok, err)
	path, tok, err = ti.NextToken()
	compareEOFCase(t, path, tok, err)
	err = ti.Close()
	if err != nil {
		t.Errorf("Expected no error")
	}
	// Make sure it works again as well
	ti = jsonstream.EmitOne(jsonstream.NewJSONPath("foo"), []byte(`"bar"`))
	path, tok, err = ti.NextToken()
	compareNextTokenOutput(t, path, tok, err)
	_ = ti.Close()
}

func TestDropDangling(t *testing.T) {
	myIter := &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Path: jsonstream.NewJSONPath("foo"), Token: nil},
		},
	}
	iter := jsonstream.DropDangling(myIter)
	path, tok, err := iter.NextToken()
	compareNextTokenOutput(t, path, tok, err)
	path, tok, err = iter.NextToken()
	compareEOFCase(t, path, tok, err)
	_ = iter.Close()
	myIter = &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Path: jsonstream.NewJSONPath(1), Token: nil},
		},
	}
	iter = jsonstream.DropDangling(myIter)
	path, tok, err = iter.NextToken()
	compareNextTokenOutput(t, path, tok, err)
	path, tok, err = iter.NextToken()
	if path.String() != "/1" {
		t.Errorf("Expected \"/1\" got \"%s\"", path.String())
	}
	if tok != nil {
		t.Errorf(expectedNilToken, tok)
	}
	if err != nil {
		t.Errorf("Expected nil error got %v", err)
	}
	_ = iter.Close()
}

func TestTokenIteratorStack(t *testing.T) {
	t.Run("empty", iteratorStackEmptyCase)
	t.Run("single", iteratorStackSingleCase)
	t.Run("two", iteratorStackTwoCase)
	myIter := &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Error: io.EOF},
		},
		errForClose: jsonstream.ErrObjectNoColon,
	}
	myIter2 := &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Error: io.EOF},
		},
	}
	tis := &jsonstream.TokenIteratorStack{}
	tis.Append(myIter2)
	tis.Append(myIter)
	path, tok, err := tis.NextToken()
	compareNextTokenOutput(t, path, tok, err)
	// Close error from first iterator
	path, tok, err = tis.NextToken()
	compareErrorCase(t, jsonstream.ErrObjectNoColon, path, tok, err)
	myIter = &testTokenIterator{
		errForClose: jsonstream.ErrObjectNoColon,
	}
	myIter2 = &testTokenIterator{}
	tis = &jsonstream.TokenIteratorStack{}
	tis.Append(myIter)
	tis.Append(nil)
	tis.Append(myIter2)
	// Close should not crash for nil and should close both real iterators
	err = tis.Close()
	if err != jsonstream.ErrObjectNoColon {
		t.Errorf("Closing erroring iterator should return it's Close error")
	}
	if !myIter.isClosed || !myIter2.isClosed {
		t.Errorf("Both iterators were not closed")
	}
}

func iteratorStackEmptyCase(t *testing.T) {
	tis := &jsonstream.TokenIteratorStack{}
	path, tok, err := tis.NextToken()
	compareEOFCase(t, path, tok, err)
	if tis.Len() != 0 {
		t.Errorf("Expected length of 0 got %d", tis.Len())
	}
	ti := tis.Top()
	if ti != nil {
		t.Errorf("Expected nil TokenIterator for Top when the Stack is empty")
	}
	err = tis.Close()
	if err != nil {
		t.Errorf(expectedNilToken, tok)
	}
}

func iteratorStackSingleCase(t *testing.T) {
	myIter := &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Error: io.ErrUnexpectedEOF},
		},
	}
	tis := &jsonstream.TokenIteratorStack{}
	tis.Append(myIter)
	path, tok, err := tis.NextToken()
	compareNextTokenOutput(t, path, tok, err)
	path, tok, err = tis.NextToken()
	compareErrorCase(t, io.ErrUnexpectedEOF, path, tok, err)
	_ = tis.Close()
}

func iteratorStackTwoCase(t *testing.T) {
	myIter := &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Error: io.ErrUnexpectedEOF},
		},
	}
	myIter2 := &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Error: io.ErrUnexpectedEOF},
		},
	}
	tis := &jsonstream.TokenIteratorStack{}
	tis.Append(myIter)
	tis.Append(myIter2)
	path, tok, err := tis.NextToken()
	compareNextTokenOutput(t, path, tok, err)
	path, tok, err = tis.NextToken()
	compareErrorCase(t, io.ErrUnexpectedEOF, path, tok, err)
	_ = tis.Close()
}

type savedItem struct {
	path     jsonstream.JSONPath
	tok      []byte
	matchLen int
}

type testSearchReplacer struct {
	isClosed        bool
	errForClose     error
	newIterCalled   bool
	iterForGet      []jsonstream.TokenIterator
	iterForGetCount int
	savedItems      []savedItem
	searchMatches   map[string]map[string]jsonstream.JSONPath
}

func (t *testSearchReplacer) Search(path jsonstream.JSONPath, tok []byte) jsonstream.JSONPath {
	if t.searchMatches == nil {
		return nil
	}
	pathMatch, ok := t.searchMatches[path.String()]
	if ok {
		tokMatch, ok := pathMatch[string(tok)]
		if ok {
			return tokMatch
		}
	}
	return nil
}

func (t *testSearchReplacer) Save(path jsonstream.JSONPath, tok []byte, matchLen int) {
	if t.savedItems == nil {
		t.savedItems = make([]savedItem, 0, 10)
	}
	t.savedItems = append(t.savedItems, savedItem{path: path, tok: tok, matchLen: matchLen})
}

func (t *testSearchReplacer) GetReplaceIter() jsonstream.TokenIterator {
	t.newIterCalled = true
	if t.iterForGetCount >= len(t.iterForGet) {
		return nil
	}
	defer func() {
		t.iterForGetCount++
	}()
	return t.iterForGet[t.iterForGetCount]
}

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

func TestSearchReplace(t *testing.T) {
	t.Run("Empty", searchReplaceEmptyCase)
	t.Run("No Match", searchReplaceNoMatchCase)
	t.Run("Match Nil Replacer", searchReplaceMatchNilReplacerCase)
	t.Run("Normal Match", searchReplaceMatchReplacerCase)
	t.Run("Recursive", searchReplaceMatchRecursive)
}

func searchReplaceEmptyCase(t *testing.T) {
	myMatcher := &testSearchReplacer{}
	myTi := &testTokenIterator{}
	sri := jsonstream.SearchReplaceWithIterator(myMatcher, false, myTi)
	path, tok, err := sri.NextToken()
	compareEOFCase(t, path, tok, err)
	err = sri.Close()
	if !myMatcher.isClosed || !myTi.isClosed || err != nil {
		t.Errorf("Expected all iterators to be closed and no error")
	}
}

func searchReplaceNoMatchCase(t *testing.T) {
	myMatcher := &testSearchReplacer{}
	myTi := &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Path: jsonstream.NewJSONPath(1), Token: []byte(`"bar"`)},
		},
	}
	sri := jsonstream.SearchReplaceWithIterator(myMatcher, false, myTi)
	path, tok, err := sri.NextToken()
	compareNextTokenOutput(t, path, tok, err)
}

func searchReplaceMatchNilReplacerCase(t *testing.T) {
	myMatcher := &testSearchReplacer{
		searchMatches: map[string]map[string]jsonstream.JSONPath{
			"/foo": {
				`"bar"`: jsonstream.NewJSONPath("foo"),
			},
		},
	}
	myTi := &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Path: jsonstream.NewJSONPath(1), Token: []byte(`"bar"`)},
		},
	}
	sri := jsonstream.SearchReplaceWithIterator(myMatcher, false, myTi)
	path, tok, err := sri.NextToken()
	compareNextTokenOutputArray(t, path, tok, err)
	// nil returned iterator case, we shouldn't crash...
	if !myMatcher.newIterCalled {
		t.Errorf("Expected GetReplaceIter() to be called")
	}
	if len(myMatcher.savedItems) != 2 {
		t.Errorf("Expected Save to be called twice it was called %d times", len(myMatcher.savedItems))
	}
}

func searchReplaceMatchReplacerCase(t *testing.T) {
	myReplacer := &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("test"), Token: []byte(`"123"`)},
		},
	}
	myMatcher := &testSearchReplacer{
		searchMatches: map[string]map[string]jsonstream.JSONPath{
			"/foo": {
				`"bar"`: jsonstream.NewJSONPath("foo"),
			},
		},
		iterForGet: []jsonstream.TokenIterator{myReplacer},
	}
	myTi := &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Path: jsonstream.NewJSONPath(1), Token: []byte(`"bar"`)},
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
		},
	}
	sri := jsonstream.SearchReplaceWithIterator(myMatcher, false, myTi)
	path, tok, err := sri.NextToken()
	compareNextTokenOutputWithPathAndToken(t, "/test", []byte(`"123"`), path, tok, err)
	path, tok, err = sri.NextToken()
	compareNextTokenOutputArray(t, path, tok, err)
}

func searchReplaceMatchRecursive(t *testing.T) {
	myReplacer := &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("test"), Token: []byte(`"123"`)},
		},
	}
	myReplacer2 := &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("test"), Token: []byte(`"123"`)},
		},
	}
	myMatcher := &testSearchReplacer{
		searchMatches: map[string]map[string]jsonstream.JSONPath{
			"/foo": {
				`"bar"`: jsonstream.NewJSONPath("foo"),
			},
		},
		iterForGet: []jsonstream.TokenIterator{myReplacer, myReplacer2},
	}
	myTi := &testTokenIterator{
		returns: []nextTokenOutput{
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
			{Path: jsonstream.NewJSONPath(1), Token: []byte(`"bar"`)},
			{Path: jsonstream.NewJSONPath("foo"), Token: []byte(`"bar"`)},
		},
	}
	sri := jsonstream.SearchReplaceWithIterator(myMatcher, true, myTi)
	path, tok, err := sri.NextToken()
	compareNextTokenOutputWithPathAndToken(t, "/test", []byte(`"123"`), path, tok, err)
	path, tok, err = sri.NextToken()
	compareNextTokenOutputArray(t, path, tok, err)
}