Add testassert.ContainsInOrder assertion helper (#457)

A small package complementing testify: ContainsInOrder asserts that
several substrings appear in a string as an ordered subsequence (each
after the previous), mirroring Laravel's assertSeeInOrder. Useful for
asserting the layout of rendered text output. Takes the same minimal
interface as testify's assertions so a *testing.T just works.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
GitOrigin-RevId: 031e0d918edc1330fc85dbbb04bc8a0ddbed7432

Author: 2 people

internal/testassert/testassert.go

@@ -0,0 +1,38 @@
+// Package testassert provides additional assertion helpers that
+// stretchr/testify does not cover.
+package testassert
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// ContainsInOrder asserts that every substr appears in s AND that each appears
+// after the previous one (an ordered subsequence).
+// Handy for asserting the layout of rendered text output.
+// Each substr is matched at its first occurrence at or after the end
+// of the previous match. Returns true when the assertion passes.
+//
+// With no substrings it passes, matching the convention of
+// strings.Contains(s, "") and testify's assert.Subset with an empty subset.
+//
+// It accepts the same minimal interface as testify's own assertions (a
+// *testing.T satisfies it), and reports the failing position through
+// t.Helper()/t.Errorf so failures point at the caller.
+func ContainsInOrder(t assert.TestingT, s string, substrs ...string) bool {
+	if h, ok := t.(interface{ Helper() }); ok {
+		h.Helper()
+	}
+	pos := 0
+	for _, sub := range substrs {
+		i := strings.Index(s[pos:], sub)
+		if i < 0 {
+			return assert.Fail(t, fmt.Sprintf("substring %q not found in expected order", sub),
+				fmt.Sprintf("expected it after offset %d in:\n%s", pos, s))
+		}
+		pos += i + len(sub)
+	}
+	return true
+}

internal/testassert/testassert_test.go

@@ -0,0 +1,52 @@
+package testassert_test
+
+import (
+	"testing"
+
+	"github.com/render-oss/cli/internal/testassert"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestContainsInOrder(t *testing.T) {
+	const s = "alpha bravo charlie"
+
+	t.Run("substrings in order pass", func(t *testing.T) {
+		assert.True(t, testassert.ContainsInOrder(t, s, "alpha", "charlie"))
+	})
+
+	t.Run("single substring present", func(t *testing.T) {
+		assert.True(t, testassert.ContainsInOrder(t, s, "bravo"))
+	})
+
+	// Vacuously true with no substrings, like strings.Contains(s, "") — asserting
+	// nothing can't be violated, and it keeps dynamically-built arg lists safe.
+	t.Run("no substrings always passes", func(t *testing.T) {
+		assert.True(t, testassert.ContainsInOrder(t, s))
+	})
+
+	t.Run("out-of-order fails", func(t *testing.T) {
+		// "alpha" appears before "charlie", so requesting them reversed fails.
+		spy := &spyT{}
+		assert.False(t, testassert.ContainsInOrder(spy, s, "charlie", "alpha"))
+		assert.True(t, spy.failed, "expected out-of-order assertion to fail")
+	})
+
+	t.Run("missing substring fails", func(t *testing.T) {
+		spy := &spyT{}
+		assert.False(t, testassert.ContainsInOrder(spy, s, "delta"))
+		assert.True(t, spy.failed, "expected missing substring to fail")
+	})
+
+	t.Run("repeated substring needs two occurrences", func(t *testing.T) {
+		// Only one "alpha", so requiring it twice must fail.
+		spy := &spyT{}
+		assert.False(t, testassert.ContainsInOrder(spy, s, "alpha", "alpha"))
+		assert.True(t, spy.failed, "expected second occurrence requirement to fail")
+	})
+}
+
+// spyT implements assert.TestingT (just Errorf) so we can observe failures on
+// the negative cases without failing the real test.
+type spyT struct{ failed bool }
+
+func (s *spyT) Errorf(string, ...any) { s.failed = true }