synapsecns/sanguine

package testsuite_test

import (
    "context"
    . "github.com/stretchr/testify/assert"
    "github.com/synapsecns/sanguine/core/mocktesting"
    "github.com/synapsecns/sanguine/core/testsuite"
    "testing"
    "time"
)

func TestMustMarshall(t *testing.T) {
    type Person struct {
        Name string `json:"name"`
        Age  int    `json:"age"`
    }
    p := Person{Name: "John Doe", Age: 30}

    // Test that MustMarshall successfully marshalls the struct to JSON
    result := testsuite.MustMarshall(t, p)
    expectedResult := `{"name":"John Doe","age":30}`
    if string(result) != expectedResult {
        t.Errorf("Expected %q but got %q", expectedResult, result)
    }

    // Test that MustMarshall fails when given an unmarshallable input
    invalidInput := make(chan int)
    mockTester := mocktesting.NewMockTester("mock tester")
    mockTester.SetOutputHandler(func(i ...interface{}) {
        // do nothing
    })
    testsuite.MustMarshall(mockTester, invalidInput)
    True(t, mockTester.Failed())
}

func TestEventually(t *testing.T) {
    // Test that Eventually returns without error when the condition is true before the context times out
    ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer cancel()
    count := 0
    testFunc := func() bool {
        count++
        return count >= 5
    }
    testsuite.Eventually(ctx, t, testFunc)
    if count != 5 {
        t.Errorf("Expected testFunc to be called 5 times but got %d", count)
    }

    // Test that Eventually returns an error when the context times out before the condition is true
    ctx, cancel = context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer cancel()
    testFunc = func() bool {
        return false
    }

    mockTester := mocktesting.NewMockTester("mock tester")
    testsuite.Eventually(ctx, mockTester, testFunc)
    True(t, mockTester.Failed())
}

// foo is a function that is used to test GetFunctionName.
func foo() {

}

// bar is a struct that is used to test GetFunctionName.
type bar struct {
}

// foo is a method that is used to test GetFunctionName.
func (b *bar) foo() {}

func TestGetFunctionName(t *testing.T) {
    // Test that GetFunctionName returns the name of a function
    functionName := testsuite.GetFunctionName(foo)
    if functionName != "foo" {
        t.Errorf("Expected GetFunctionName to return %q but got %q", "foo", functionName)
    }

    // Test that GetFunctionName returns the name of a method
    b := bar{}
    functionName = testsuite.GetFunctionName(b.foo)
    if functionName != "foo" {
        t.Errorf("Expected GetFunctionName to return %q but got %q", "foo", functionName)
    }
}