Skip to content

Git designed for AI agents.

5.2 KB
Raw Blame
package lines

import (
	"bytes"
	"regexp"
	"testing"

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

func TestLinesSend_hasNextPageAtChunkBoundary(t *testing.T) {
	// Override ItemsPerMessage to a small value for testing
	oldItemsPerMessage := ItemsPerMessage
	ItemsPerMessage = 2
	t.Cleanup(func() { ItemsPerMessage = oldItemsPerMessage })

	// 3 items total, limit=2 (equal to ItemsPerMessage).
	// The bug was that when the limit aligns with the chunk size,
	// hasNextPage was incorrectly reported as false.
	reader := bytes.NewBufferString("a\nb\nc")
	var allOut [][]byte
	var lastNextPage bool

	sender := func(in [][]byte, hasNextPage bool) error {
		allOut = append(allOut, in...)
		lastNextPage = hasNextPage
		return nil
	}

	err := Send(reader, sender, SenderOpts{
		Limit:     2,
		Delimiter: '\n',
	})
	require.NoError(t, err)
	require.Equal(t, [][]byte{[]byte("a"), []byte("b")}, allOut)
	require.True(t, lastNextPage, "hasNextPage should be true when limit equals chunk size and more items exist")
}

func TestLinesSend_noNextPageAtChunkBoundaryWhenExhausted(t *testing.T) {
	// Override ItemsPerMessage to a small value for testing
	oldItemsPerMessage := ItemsPerMessage
	ItemsPerMessage = 2
	t.Cleanup(func() { ItemsPerMessage = oldItemsPerMessage })

	// 2 items total, limit=2 (equal to ItemsPerMessage), no more items.
	// hasNextPage should be false since all items fit within the limit.
	reader := bytes.NewBufferString("a\nb")
	var allOut [][]byte
	var lastNextPage bool

	sender := func(in [][]byte, hasNextPage bool) error {
		allOut = append(allOut, in...)
		lastNextPage = hasNextPage
		return nil
	}

	err := Send(reader, sender, SenderOpts{
		Limit:     2,
		Delimiter: '\n',
	})
	require.NoError(t, err)
	require.Equal(t, [][]byte{[]byte("a"), []byte("b")}, allOut)
	require.False(t, lastNextPage, "hasNextPage should be false when all items fit within the limit")
}

func TestLinesSend(t *testing.T) {
	expected := [][]byte{
		[]byte("mepmep"),
		[]byte("foo"),
		[]byte("bar"),
	}

	tcs := []struct {
		desc           string
		filter         *regexp.Regexp
		limit          int
		isPageToken    func([]byte) bool
		isNextPage     bool
		PageTokenError bool
		output         [][]byte
	}{
		{
			desc:   "high limit",
			limit:  100,
			output: expected,
		},
		{
			desc:   "limit is -1",
			limit:  -1,
			output: [][]byte(nil),
		},
		{
			desc:   "limit is 0",
			limit:  0,
			output: [][]byte(nil),
		},
		{
			desc:       "limit 1",
			limit:      1,
			output:     expected[0:1],
			isNextPage: true,
		},
		{
			desc:       "limit 2",
			limit:      2,
			output:     expected[0:2],
			isNextPage: true,
		},
		{
			desc:   "limit 3",
			limit:  3,
			output: expected,
		},
		{
			desc:   "filter and limit",
			limit:  1,
			filter: regexp.MustCompile("foo"),
			output: expected[1:2],
		},
		{
			desc:       "filter with limit and next page",
			filter:     regexp.MustCompile("foo|bar"),
			limit:      1,
			output:     expected[1:2],
			isNextPage: true,
		},
		{
			desc:        "skip lines",
			limit:       100,
			isPageToken: func(line []byte) bool { return bytes.HasPrefix(line, expected[0]) },
			output:      expected[1:3],
		},
		{
			desc:        "page token is invalid",
			limit:       100,
			isPageToken: func(line []byte) bool { return false },
			output:      [][]byte(nil),
		},
		{
			desc:           "page token is invalid and page token error is set",
			limit:          100,
			isPageToken:    func(line []byte) bool { return false },
			PageTokenError: true,
		},
		{
			desc:  "page token with limit and next page",
			limit: 1,
			isPageToken: func(line []byte) bool {
				// Skip "mepmep", start from "foo"
				return string(line) == "mepmep"
			},
			output:     expected[1:2],
			isNextPage: true, // Should be true since "bar" exists after the limit
		},
		{
			desc:  "page token with limit at end - no next page",
			limit: 2,
			isPageToken: func(line []byte) bool {
				// Skip "mepmep", start from "foo"
				return string(line) == "mepmep"
			},
			output: expected[1:3],
		},
		{
			desc:  "page token skips all remaining lines",
			limit: 1,
			isPageToken: func(line []byte) bool {
				// Skip everything including "bar" (last line)
				return string(line) == "bar"
			},
			output: [][]byte(nil),
		},
		{
			desc:  "page token with zero limit",
			limit: 0,
			isPageToken: func(line []byte) bool {
				// Skip "mepmep", start from "foo"
				return string(line) == "mepmep"
			},
			PageTokenError: true,
		},
		{
			desc:        "skip no lines",
			limit:       100,
			isPageToken: func(_ []byte) bool { return true },
			output:      expected,
		},
	}

	for _, tc := range tcs {
		t.Run(tc.desc, func(t *testing.T) {
			reader := bytes.NewBufferString("mepmep\nfoo\nbar")
			var out [][]byte
			var nextPage bool

			sender := func(in [][]byte, hasNextPage bool) error {
				out = in
				nextPage = hasNextPage
				return nil
			}

			err := Send(reader, sender, SenderOpts{
				Limit:          tc.limit,
				IsPageToken:    tc.isPageToken,
				PageTokenError: tc.PageTokenError,
				Filter:         tc.filter,
				Delimiter:      '\n',
			})

			if tc.PageTokenError {
				require.Error(t, err)
			} else {
				require.NoError(t, err)
				require.Equal(t, tc.output, out)
				require.Equal(t, tc.isNextPage, nextPage)
			}
		})
	}
}