assert

func ArrayContains ¶

func ArrayContains[T any](expected T) Kleisli[[]T]

ArrayContains tests if a value is contained in an array.

Example:

func TestArrayContains(t *testing.T) {
    numbers := []int{1, 2, 3, 4, 5}
    assert.ArrayContains(3)(numbers)(t)  // Passes
    assert.ArrayContains(10)(numbers)(t)  // Fails

    names := []string{"Alice", "Bob", "Charlie"}
    assert.ArrayContains("Bob")(names)(t)  // Passes
}

func ArrayLength ¶

func ArrayLength[T any](expected int) Kleisli[[]T]

ArrayLength tests if an array has the expected length.

Example:

func TestArrayLength(t *testing.T) {
    numbers := []int{1, 2, 3, 4, 5}
    assert.ArrayLength[int](5)(numbers)(t)  // Passes
    assert.ArrayLength[int](3)(numbers)(t)  // Fails
}

func ContainsKey ¶

func ContainsKey[T any, K comparable](expected K) Kleisli[map[K]T]

ContainsKey tests if a key is contained in a map.

Example:

func TestContainsKey(t *testing.T) {
    config := map[string]int{"timeout": 30, "retries": 3}
    assert.ContainsKey[int]("timeout")(config)(t)  // Passes
    assert.ContainsKey[int]("maxSize")(config)(t)  // Fails
}

func Equal ¶

func Equal[T any](expected T) Kleisli[T]

Equal tests if the expected and the actual values are equal.

This is one of the most commonly used assertions. It follows the "data last" principle - you provide the expected value first, then the actual value, and finally the testing.T context.

Example:

func TestEqual(t *testing.T) {
    result := 2 + 2
    assert.Equal(4)(result)(t)  // Passes

    name := "Alice"
    assert.Equal("Alice")(name)(t)  // Passes

    // Can be composed with other assertions
    user := User{Name: "Bob", Age: 30}
    assertions := assert.AllOf([]assert.Reader{
        assert.Equal("Bob")(user.Name),
        assert.Equal(30)(user.Age),
    })
    assertions(t)
}

func NotContainsKey ¶

func NotContainsKey[T any, K comparable](expected K) Kleisli[map[K]T]

NotContainsKey tests if a key is not contained in a map.

Example:

func TestNotContainsKey(t *testing.T) {
    config := map[string]int{"timeout": 30, "retries": 3}
    assert.NotContainsKey[int]("maxSize")(config)(t)  // Passes
    assert.NotContainsKey[int]("timeout")(config)(t)  // Fails
}

func NotEqual ¶

func NotEqual[T any](expected T) Kleisli[T]

NotEqual tests if the expected and the actual values are not equal.

This function follows the "data last" principle - you provide the expected value first, then the actual value, and finally the testing.T context.

Example:

func TestNotEqual(t *testing.T) {
    value := 42
    assert.NotEqual(10)(value)(t)  // Passes: 42 != 10
    assert.NotEqual(42)(value)(t)  // Fails: 42 == 42
}

func RecordLength ¶

func RecordLength[K comparable, T any](expected int) Kleisli[map[K]T]

RecordLength tests if a map has the expected length.

Example:

func TestRecordLength(t *testing.T) {
    config := map[string]string{"host": "localhost", "port": "8080"}
    assert.RecordLength[string, string](2)(config)(t)  // Passes
    assert.RecordLength[string, string](3)(config)(t)  // Fails
}

func StringLength ¶

func StringLength[K comparable, T any](expected int) Kleisli[string]

StringLength tests if a string has the expected length.

Example:

func TestStringLength(t *testing.T) {
    message := "Hello"
    assert.StringLength[any, any](5)(message)(t)  // Passes
    assert.StringLength[any, any](10)(message)(t)  // Fails
}

func That ¶

func That[T any](pred Predicate[T]) Kleisli[T]

That asserts that a particular predicate matches.

This is a powerful function that allows you to create custom assertions using predicates.

Example:

func TestThat(t *testing.T) {
    // Test if a number is positive
    isPositive := N.MoreThan(0)
    assert.That(isPositive)(42)(t)  // Passes
    assert.That(isPositive)(-5)(t)  // Fails

    // Test if a string is uppercase
    isUppercase := func(s string) bool { return s == strings.ToUpper(s) }
    assert.That(isUppercase)("HELLO")(t)  // Passes
    assert.That(isUppercase)("Hello")(t)  // Fails

    // Can be combined with Local for property testing
    type User struct { Age int }
    ageIsAdult := assert.Local(func(u User) int { return u.Age })(
        assert.That(func(age int) bool { return age >= 18 }),
    )
    user := User{Age: 25}
    ageIsAdult(user)(t)  // Passes
}

func TraverseArray ¶ added in v2.2.18

func TraverseArray[T any](f func(T) Pair[string, Reader]) Kleisli[[]T]

TraverseArray transforms an array of values into a test suite by applying a function that generates named test cases for each element.

This function enables data-driven testing where you have a collection of test inputs and want to run a named subtest for each one. It follows the functional programming pattern of "traverse" - transforming a collection while preserving structure and accumulating effects (in this case, test execution).

The function takes each element of the array, applies the provided function to generate a Pair of (test name, test assertion), and runs each as a separate subtest using Go's t.Run. All subtests must pass for the overall test to pass.

Parameters ¶

• f: A function that takes a value of type T and returns a Pair containing:
• Head: The test name (string) for the subtest
• Tail: The test assertion (Reader) to execute

Returns ¶

• A Kleisli function that takes an array of T and returns a Reader that:
• Executes each element as a named subtest
• Returns true only if all subtests pass
• Provides proper test isolation and reporting via t.Run

Use Cases ¶

• Data-driven testing with multiple test cases
• Parameterized tests where each parameter gets its own subtest
• Testing collections where each element needs validation
• Property-based testing with generated test data

Example - Basic Data-Driven Testing ¶

func TestMathOperations(t *testing.T) {
    type TestCase struct {
        Input    int
        Expected int
    }

    testCases := []TestCase{
        {Input: 2, Expected: 4},
        {Input: 3, Expected: 9},
        {Input: 4, Expected: 16},
    }

    square := func(n int) int { return n * n }

    traverse := assert.TraverseArray(func(tc TestCase) assert.Pair[string, assert.Reader] {
        name := fmt.Sprintf("square(%d)=%d", tc.Input, tc.Expected)
        assertion := assert.Equal(tc.Expected)(square(tc.Input))
        return pair.MakePair(name, assertion)
    })

    traverse(testCases)(t)
}

Example - String Validation ¶

func TestStringValidation(t *testing.T) {
    inputs := []string{"hello", "world", "test"}

    traverse := assert.TraverseArray(func(s string) assert.Pair[string, assert.Reader] {
        return pair.MakePair(
            fmt.Sprintf("validate_%s", s),
            assert.AllOf([]assert.Reader{
                assert.StringNotEmpty(s),
                assert.That(func(str string) bool { return len(str) > 0 })(s),
            }),
        )
    })

    traverse(inputs)(t)
}

Example - Complex Object Testing ¶

func TestUsers(t *testing.T) {
    type User struct {
        Name  string
        Age   int
        Email string
    }

    users := []User{
        {Name: "Alice", Age: 30, Email: "alice@example.com"},
        {Name: "Bob", Age: 25, Email: "bob@example.com"},
    }

    traverse := assert.TraverseArray(func(u User) assert.Pair[string, assert.Reader] {
        return pair.MakePair(
            fmt.Sprintf("user_%s", u.Name),
            assert.AllOf([]assert.Reader{
                assert.StringNotEmpty(u.Name),
                assert.That(func(age int) bool { return age > 0 })(u.Age),
                assert.That(func(email string) bool {
                    return len(email) > 0 && strings.Contains(email, "@")
                })(u.Email),
            }),
        )
    })

    traverse(users)(t)
}

Comparison with RunAll ¶

TraverseArray and RunAll serve similar purposes but differ in their approach:

• TraverseArray: Generates test cases from an array of data

• Input: Array of values + function to generate test cases

• Use when: You have test data and need to generate test cases from it

• RunAll: Executes pre-defined named test cases

• Input: Map of test names to assertions

• Use when: You have already defined test cases with names

Related Functions ¶

• SequenceSeq2: Similar but works with Go iterators (Seq2) instead of arrays
• RunAll: Executes a map of named test cases
• AllOf: Combines multiple assertions without subtests

References ¶

• Haskell traverse: https://hackage.haskell.org/package/base/docs/Data-Traversable.html#v:traverse
• Go subtests: https://go.dev/blog/subtests

func TraverseRecord ¶ added in v2.2.18

func TraverseRecord[T any](f Kleisli[T]) Kleisli[map[string]T]

TraverseRecord transforms a map of values into a test suite by applying a function that generates test assertions for each map entry.

This function enables data-driven testing where you have a map of test data and want to run a named subtest for each entry. The map keys become test names, and the function transforms each value into a test assertion. It follows the functional programming pattern of "traverse" - transforming a collection while preserving structure and accumulating effects (in this case, test execution).

The function takes each key-value pair from the map, applies the provided function to generate a Reader assertion, and runs each as a separate subtest using Go's t.Run. All subtests must pass for the overall test to pass.

Parameters ¶

• f: A Kleisli function that takes a value of type T and returns a Reader assertion

Returns ¶

• A Kleisli function that takes a map[string]T and returns a Reader that:
• Executes each map entry as a named subtest (using the key as the test name)
• Returns true only if all subtests pass
• Provides proper test isolation and reporting via t.Run

Use Cases ¶

• Data-driven testing with named test cases in a map
• Testing configuration maps where keys are meaningful names
• Validating collections where natural keys exist
• Property-based testing with named scenarios

Example - Basic Configuration Testing ¶

func TestConfigurations(t *testing.T) {
    configs := map[string]int{
        "timeout":     30,
        "maxRetries":  3,
        "bufferSize":  1024,
    }

    validatePositive := assert.That(func(n int) bool { return n > 0 })

    traverse := assert.TraverseRecord(validatePositive)
    traverse(configs)(t)
}

Example - User Validation ¶

func TestUserMap(t *testing.T) {
    type User struct {
        Name string
        Age  int
    }

    users := map[string]User{
        "alice": {Name: "Alice", Age: 30},
        "bob":   {Name: "Bob", Age: 25},
        "carol": {Name: "Carol", Age: 35},
    }

    validateUser := func(u User) assert.Reader {
        return assert.AllOf([]assert.Reader{
            assert.StringNotEmpty(u.Name),
            assert.That(func(age int) bool { return age > 0 && age < 150 })(u.Age),
        })
    }

    traverse := assert.TraverseRecord(validateUser)
    traverse(users)(t)
}

Example - API Endpoint Testing ¶

func TestEndpoints(t *testing.T) {
    type Endpoint struct {
        Path   string
        Method string
    }

    endpoints := map[string]Endpoint{
        "get_users":    {Path: "/api/users", Method: "GET"},
        "create_user":  {Path: "/api/users", Method: "POST"},
        "delete_user":  {Path: "/api/users/:id", Method: "DELETE"},
    }

    validateEndpoint := func(e Endpoint) assert.Reader {
        return assert.AllOf([]assert.Reader{
            assert.StringNotEmpty(e.Path),
            assert.That(func(path string) bool {
                return strings.HasPrefix(path, "/api/")
            })(e.Path),
            assert.That(func(method string) bool {
                return method == "GET" || method == "POST" ||
                       method == "PUT" || method == "DELETE"
            })(e.Method),
        })
    }

    traverse := assert.TraverseRecord(validateEndpoint)
    traverse(endpoints)(t)
}

Comparison with TraverseArray ¶

TraverseRecord and TraverseArray serve similar purposes but differ in their input:

• TraverseRecord: Works with maps (records)

• Input: Map with string keys + transformation function

• Use when: You have named test data in a map

• Test names: Derived from map keys

• TraverseArray: Works with arrays

• Input: Array of values + function that generates names and assertions

• Use when: You have sequential test data

• Test names: Generated by the transformation function

Comparison with SequenceRecord ¶

TraverseRecord and SequenceRecord are closely related:

• TraverseRecord: Transforms values into assertions

• Input: map[string]T + function T -> Reader

• Use when: You need to transform data before asserting

• SequenceRecord: Executes pre-defined assertions

• Input: map[string]Reader

• Use when: Assertions are already defined

Related Functions ¶

• SequenceRecord: Similar but takes pre-defined assertions
• TraverseArray: Similar but works with arrays
• RunAll: Alias for SequenceRecord

References ¶

• Haskell traverse: https://hackage.haskell.org/package/base/docs/Data-Traversable.html#v:traverse
• Go subtests: https://go.dev/blog/subtests

func AllOf ¶

func AllOf(readers []Reader) Reader

AllOf combines multiple assertion Readers into a single Reader that passes only if all assertions pass.

This function uses boolean AND logic (MonoidAll) to combine the results of all assertions. If any assertion fails, the combined assertion fails.

This is useful for grouping related assertions together and ensuring all conditions are met.

Parameters:

• readers: Array of assertion Readers to combine

Returns:

• A single Reader that performs all assertions and returns true only if all pass

Example:

func TestUser(t *testing.T) {
    user := User{Name: "Alice", Age: 30, Active: true}
    assertions := assert.AllOf([]assert.Reader{
        assert.Equal("Alice")(user.Name),
        assert.Equal(30)(user.Age),
        assert.Equal(true)(user.Active),
    })
    assertions(t)
}

func ArrayEmpty ¶ added in v2.2.18

func ArrayEmpty[T any](arr []T) Reader

ArrayEmpty checks if an array is empty.

This is the complement of ArrayNotEmpty, asserting that a slice has no elements.

Example:

func TestArrayEmpty(t *testing.T) {
    empty := []int{}
    assert.ArrayEmpty(empty)(t)  // Passes

    numbers := []int{1, 2, 3}
    assert.ArrayEmpty(numbers)(t)  // Fails
}

func ArrayNotEmpty ¶

func ArrayNotEmpty[T any](arr []T) Reader

ArrayNotEmpty checks if an array is not empty.

Example:

func TestArrayNotEmpty(t *testing.T) {
    numbers := []int{1, 2, 3}
    assert.ArrayNotEmpty(numbers)(t)  // Passes

    empty := []int{}
    assert.ArrayNotEmpty(empty)(t)  // Fails
}

func Error ¶

func Error(err error) Reader

Error validates that there is an error.

This is used to assert that operations fail as expected.

Example:

func TestError(t *testing.T) {
    err := validateInput("")
    assert.Error(err)(t)  // Passes if err is not nil

    err2 := validateInput("valid")
    assert.Error(err2)(t)  // Fails if err2 is nil
}

func Failure ¶

func Failure[T any](res Result[T]) Reader

Failure checks if a Result represents failure.

This is a convenience function for testing Result types from the fp-go library.

Example:

func TestFailure(t *testing.T) {
    res := result.Error[int](errors.New("something went wrong"))
    assert.Failure(res)(t)  // Passes

    successRes := result.Of[int](42)
    assert.Failure(successRes)(t)  // Fails
}

func FromReaderIO ¶ added in v2.2.18

func FromReaderIO(ri ReaderIO[Reader]) Reader

FromReaderIO converts a ReaderIO[Reader] into a Reader.

This function bridges the gap between context-aware, IO-based computations (ReaderIO) and the simpler Reader type used for test assertions. It executes the ReaderIO computation using the test's context and returns the resulting Reader.

Unlike FromReaderIOResult, this function does not handle errors explicitly - it assumes the IO operation will succeed or that any errors are handled within the ReaderIO itself.

The conversion process:

1. Executes the ReaderIO with the test context (t.Context())
2. Runs the resulting IO operation ()
3. Returns a Reader that can be applied to *testing.T

This is particularly useful when you have test assertions that need to:

• Access context for cancellation or deadlines
• Perform IO operations that don't fail (or handle failures internally)
• Integrate with context-aware testing utilities

Parameters:

• ri: A ReaderIO that produces a Reader when given a context and executed

Returns:

• A Reader that can be directly applied to *testing.T for assertion

Example:

func TestWithIO(t *testing.T) {
    // Create a ReaderIO that performs an IO operation
    logAndCheck := func(ctx context.Context) func() assert.Reader {
        return func() assert.Reader {
            // Log something using context
            logger.InfoContext(ctx, "Running test")
            // Return an assertion
            return assert.Equal(42)(computeValue())
        }
    }

    // Convert to Reader and execute
    assertion := assert.FromReaderIO(logAndCheck)
    assertion(t)
}

func FromReaderIOResult ¶ added in v2.2.18

func FromReaderIOResult(ri ReaderIOResult[Reader]) Reader

FromReaderIOResult converts a ReaderIOResult[Reader] into a Reader.

This function bridges the gap between context-aware, IO-based computations that may fail (ReaderIOResult) and the simpler Reader type used for test assertions. It executes the ReaderIOResult computation using the test's context, handles any potential errors by converting them to test failures via NoError, and returns the resulting Reader.

The conversion process:

1. Executes the ReaderIOResult with the test context (t.Context())
2. Runs the resulting IO operation ()
3. Extracts the Result, converting errors to test failures using NoError
4. Returns a Reader that can be applied to *testing.T

This is particularly useful when you have test assertions that need to:

• Access context for cancellation or deadlines
• Perform IO operations (file access, network calls, etc.)
• Handle potential errors gracefully in tests

Parameters:

• ri: A ReaderIOResult that produces a Reader when given a context and executed

Returns:

• A Reader that can be directly applied to *testing.T for assertion

Example:

func TestWithContext(t *testing.T) {
    // Create a ReaderIOResult that performs an IO operation
    checkDatabase := func(ctx context.Context) func() result.Result[assert.Reader] {
        return func() result.Result[assert.Reader] {
            // Simulate database check
            if err := db.PingContext(ctx); err != nil {
                return result.Error[assert.Reader](err)
            }
            return result.Of[assert.Reader](assert.NoError(nil))
        }
    }

    // Convert to Reader and execute
    assertion := assert.FromReaderIOResult(checkDatabase)
    assertion(t)
}

func NoError ¶

func NoError(err error) Reader

NoError validates that there is no error.

This is commonly used to assert that operations complete successfully.

Example:

func TestNoError(t *testing.T) {
    err := doSomething()
    assert.NoError(err)(t)  // Passes if err is nil

    // Can be used with result types
    result := result.TryCatch(func() (int, error) {
        return 42, nil
    })
    assert.Success(result)(t)  // Uses NoError internally
}

func RecordEmpty ¶ added in v2.2.18

func RecordEmpty[K comparable, T any](mp map[K]T) Reader

RecordEmpty checks if a map is empty.

This is the complement of RecordNotEmpty, asserting that a map has no key-value pairs.

Example:

func TestRecordEmpty(t *testing.T) {
    empty := map[string]int{}
    assert.RecordEmpty(empty)(t)  // Passes

    config := map[string]int{"timeout": 30}
    assert.RecordEmpty(config)(t)  // Fails
}

func RecordNotEmpty ¶

func RecordNotEmpty[K comparable, T any](mp map[K]T) Reader

RecordNotEmpty checks if a map is not empty.

Example:

func TestRecordNotEmpty(t *testing.T) {
    config := map[string]int{"timeout": 30, "retries": 3}
    assert.RecordNotEmpty(config)(t)  // Passes

    empty := map[string]int{}
    assert.RecordNotEmpty(empty)(t)  // Fails
}

func RunAll ¶

func RunAll(testcases map[string]Reader) Reader

RunAll executes a map of named test cases, running each as a subtest.

This function creates a Reader that runs multiple named test cases using Go's t.Run for proper test isolation and reporting. Each test case is executed as a separate subtest with its own name.

The function returns true only if all subtests pass. This allows for better test organization and clearer test output.

Parameters:

• testcases: Map of test names to assertion Readers

Returns:

• A Reader that executes all named test cases and returns true if all pass

Example:

func TestMathOperations(t *testing.T) {
    testcases := map[string]assert.Reader{
        "addition":       assert.Equal(4)(2 + 2),
        "multiplication": assert.Equal(6)(2 * 3),
        "subtraction":    assert.Equal(1)(3 - 2),
    }
    assert.RunAll(testcases)(t)
}

func SequenceRecord ¶ added in v2.2.18

func SequenceRecord(m map[string]Reader) Reader

SequenceRecord executes a map of named test cases as subtests.

This function takes a map where keys are test names and values are test assertions (Reader), and executes each as a separate subtest using Go's t.Run. It's the record (map) equivalent of SequenceSeq2 and is actually aliased as RunAll for convenience.

The function iterates through all map entries, running each as a named subtest. All subtests must pass for the overall test to pass. This provides proper test isolation and clear reporting of which specific test cases fail.

Parameters ¶

• m: A map[string]Reader where:
• Keys: Test names (strings) for the subtests
• Values: Test assertions (Reader) to execute

Returns ¶

• A Reader that:
• Executes each map entry as a named subtest
• Returns true only if all subtests pass
• Provides proper test isolation via t.Run

Use Cases ¶

• Executing a collection of pre-defined named test cases
• Organizing related tests in a map structure
• Running multiple assertions with descriptive names
• Building test suites programmatically

Example - Basic Named Tests ¶

func TestMathOperations(t *testing.T) {
    tests := map[string]assert.Reader{
        "addition":       assert.Equal(4)(2 + 2),
        "subtraction":    assert.Equal(1)(3 - 2),
        "multiplication": assert.Equal(6)(2 * 3),
        "division":       assert.Equal(2)(6 / 3),
    }

    assert.SequenceRecord(tests)(t)
}

Example - String Validation Suite ¶

func TestStringValidations(t *testing.T) {
    testString := "hello world"

    tests := map[string]assert.Reader{
        "not_empty":      assert.StringNotEmpty(testString),
        "correct_length": assert.StringLength[any, any](11)(testString),
        "has_space":      assert.That(func(s string) bool {
            return strings.Contains(s, " ")
        })(testString),
        "lowercase":      assert.That(func(s string) bool {
            return s == strings.ToLower(s)
        })(testString),
    }

    assert.SequenceRecord(tests)(t)
}

Example - Complex Object Validation ¶

func TestUserValidation(t *testing.T) {
    type User struct {
        Name  string
        Age   int
        Email string
    }

    user := User{Name: "Alice", Age: 30, Email: "alice@example.com"}

    tests := map[string]assert.Reader{
        "name_not_empty": assert.StringNotEmpty(user.Name),
        "age_positive":   assert.That(func(age int) bool { return age > 0 })(user.Age),
        "age_reasonable": assert.That(func(age int) bool { return age < 150 })(user.Age),
        "email_valid":    assert.That(func(email string) bool {
            return strings.Contains(email, "@") && strings.Contains(email, ".")
        })(user.Email),
    }

    assert.SequenceRecord(tests)(t)
}

Example - Array Validation Suite ¶

func TestArrayValidations(t *testing.T) {
    numbers := []int{1, 2, 3, 4, 5}

    tests := map[string]assert.Reader{
        "not_empty":      assert.ArrayNotEmpty(numbers),
        "correct_length": assert.ArrayLength[int](5)(numbers),
        "contains_three": assert.ArrayContains(3)(numbers),
        "all_positive":   assert.That(func(arr []int) bool {
            for _, n := range arr {
                if n <= 0 {
                    return false
                }
            }
            return true
        })(numbers),
    }

    assert.SequenceRecord(tests)(t)
}

Comparison with TraverseRecord ¶

SequenceRecord and TraverseRecord are closely related:

• SequenceRecord: Executes pre-defined assertions

• Input: map[string]Reader (assertions already created)

• Use when: You have already defined test cases with assertions

• TraverseRecord: Transforms values into assertions

• Input: map[string]T + function T -> Reader

• Use when: You need to transform data before asserting

Comparison with SequenceSeq2 ¶

SequenceRecord and SequenceSeq2 serve similar purposes but differ in their input:

• SequenceRecord: Works with maps

• Input: map[string]Reader

• Use when: You have named test cases in a map

• Iteration order: Non-deterministic (map iteration)

• SequenceSeq2: Works with iterators

• Input: Seq2[string, Reader]

• Use when: You have test cases in an iterator

• Iteration order: Deterministic (iterator order)

Note on Map Iteration Order ¶

Go maps have non-deterministic iteration order. If test execution order matters, consider using SequenceSeq2 with an iterator that provides deterministic ordering, or use TraverseArray with a slice of test cases.

Related Functions ¶

• RunAll: Alias for SequenceRecord
• TraverseRecord: Similar but transforms values into assertions
• SequenceSeq2: Similar but works with iterators
• TraverseArray: Similar but works with arrays

References ¶

• Go subtests: https://go.dev/blog/subtests
• Haskell sequence: https://hackage.haskell.org/package/base/docs/Data-Traversable.html#v:sequence

func SequenceSeq2 ¶ added in v2.2.18

func SequenceSeq2[T any](s Seq2[string, Reader]) Reader

SequenceSeq2 executes a sequence of named test cases provided as a Go iterator.

This function takes a Seq2 iterator that yields (name, assertion) pairs and executes each as a separate subtest using Go's t.Run. It's similar to TraverseArray but works directly with Go's iterator protocol (introduced in Go 1.23) rather than requiring an array.

The function iterates through all test cases, running each as a named subtest. All subtests must pass for the overall test to pass. This provides proper test isolation and clear reporting of which specific test cases fail.

Parameters ¶

• s: A Seq2 iterator that yields pairs of:
• Key: Test name (string) for the subtest
• Value: Test assertion (Reader) to execute

Returns ¶

• A Reader that:
• Executes each test case as a named subtest
• Returns true only if all subtests pass
• Provides proper test isolation via t.Run

Use Cases ¶

• Working with iterator-based test data
• Lazy evaluation of test cases
• Integration with Go 1.23+ iterator patterns
• Memory-efficient testing of large test suites

Example - Basic Usage with Iterator ¶

func TestWithIterator(t *testing.T) {
    // Create an iterator of test cases
    testCases := func(yield func(string, assert.Reader) bool) {
        if !yield("test_addition", assert.Equal(4)(2+2)) {
            return
        }
        if !yield("test_subtraction", assert.Equal(1)(3-2)) {
            return
        }
        if !yield("test_multiplication", assert.Equal(6)(2*3)) {
            return
        }
    }

    assert.SequenceSeq2(testCases)(t)
}

Example - Generated Test Cases ¶

func TestGeneratedCases(t *testing.T) {
    // Generate test cases on the fly
    generateTests := func(yield func(string, assert.Reader) bool) {
        for i := 1; i <= 5; i++ {
            name := fmt.Sprintf("test_%d", i)
            assertion := assert.Equal(i*i)(i * i)
            if !yield(name, assertion) {
                return
            }
        }
    }

    assert.SequenceSeq2(generateTests)(t)
}

Example - Filtering Test Cases ¶

func TestFilteredCases(t *testing.T) {
    type TestCase struct {
        Name     string
        Input    int
        Expected int
        Skip     bool
    }

    allCases := []TestCase{
        {Name: "test1", Input: 2, Expected: 4, Skip: false},
        {Name: "test2", Input: 3, Expected: 9, Skip: true},
        {Name: "test3", Input: 4, Expected: 16, Skip: false},
    }

    // Create iterator that filters out skipped tests
    activeTests := func(yield func(string, assert.Reader) bool) {
        for _, tc := range allCases {
            if !tc.Skip {
                assertion := assert.Equal(tc.Expected)(tc.Input * tc.Input)
                if !yield(tc.Name, assertion) {
                    return
                }
            }
        }
    }

    assert.SequenceSeq2(activeTests)(t)
}

Comparison with TraverseArray ¶

SequenceSeq2 and TraverseArray serve similar purposes but differ in their input:

• SequenceSeq2: Works with iterators (Seq2)

• Input: Iterator yielding (name, assertion) pairs

• Use when: Working with Go 1.23+ iterators or lazy evaluation

• Memory: More efficient for large test suites (lazy evaluation)

• TraverseArray: Works with arrays

• Input: Array of values + transformation function

• Use when: You have an array of test data

• Memory: All test data must be in memory

Comparison with RunAll ¶

SequenceSeq2 and RunAll are very similar:

• SequenceSeq2: Takes an iterator (Seq2)
• RunAll: Takes a map[string]Reader

Both execute named test cases as subtests. Choose based on your data structure: use SequenceSeq2 for iterators, RunAll for maps.

Related Functions ¶

• TraverseArray: Similar but works with arrays instead of iterators
• RunAll: Executes a map of named test cases
• AllOf: Combines multiple assertions without subtests

References ¶

• Go iterators: https://go.dev/blog/range-functions
• Go subtests: https://go.dev/blog/subtests
• Haskell sequence: https://hackage.haskell.org/package/base/docs/Data-Traversable.html#v:sequence

func StringNotEmpty ¶

func StringNotEmpty(s string) Reader

StringNotEmpty checks if a string is not empty.

Example:

func TestStringNotEmpty(t *testing.T) {
    message := "Hello, World!"
    assert.StringNotEmpty(message)(t)  // Passes

    empty := ""
    assert.StringNotEmpty(empty)(t)  // Fails
}

func Success ¶

func Success[T any](res Result[T]) Reader

Success checks if a Result represents success.

This is a convenience function for testing Result types from the fp-go library.

Example:

func TestSuccess(t *testing.T) {
    res := result.Of[int](42)
    assert.Success(res)(t)  // Passes

    failedRes := result.Error[int](errors.New("failed"))
    assert.Success(failedRes)(t)  // Fails
}