synapsecns/sanguine

package client_test

import (
    "context"
    "fmt"
    "math/big"
    "net/url"
    "sync"
    "testing"

    "github.com/stretchr/testify/suite"
    "github.com/synapsecns/sanguine/core"
    "github.com/synapsecns/sanguine/core/metrics"
    "github.com/synapsecns/sanguine/core/metrics/localmetrics"
    "github.com/synapsecns/sanguine/core/testsuite"
    "github.com/synapsecns/sanguine/ethergo/backends"
    "github.com/synapsecns/sanguine/ethergo/backends/geth"
    "github.com/synapsecns/sanguine/services/omnirpc/client"
    "github.com/synapsecns/sanguine/services/omnirpc/metadata"
    "github.com/synapsecns/sanguine/services/omnirpc/testhelper"
    "golang.org/x/sync/errgroup"
)

type TestClientSuite struct {
    *testsuite.TestSuite
    // testBackends contins a list of all test backends
    testBackends []backends.SimulatedTestBackend
    endpoint     string
    client       client.RPCClient
    metrics      metrics.Handler
}

func NewTestClientSuite(tb testing.TB) *TestClientSuite {
    tb.Helper()
    return &TestClientSuite{
        TestSuite: testsuite.NewTestSuite(tb),
    }
}

func TestTestClientSuite(t *testing.T) {
    suite.Run(t, NewTestClientSuite(t))
}

func (s *TestClientSuite) SetupSuite() {
    s.TestSuite.SetupSuite()

    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        defer wg.Done()
        s.SetupBackends(s.GetSuiteContext())
    }()

    go func() {
        defer wg.Done()
        s.SetupJaeger()
    }()

    wg.Wait()
}

func (s *TestClientSuite) SetupTest() {
    s.TestSuite.SetupTest()

    s.endpoint = s.getHostURL(testhelper.NewOmnirpcServer(s.GetTestContext(), s.T(), s.testBackends...))
    s.client = client.NewOmnirpcClient(s.endpoint, s.metrics, client.WithCaptureReqRes())
}

func (s *TestClientSuite) SetupJaeger() {
    // don't use metrics on ci for integration tests
    isCI := core.GetEnvBool("CI", false)
    useMetrics := !isCI
    metricsHandler := metrics.Null

    if useMetrics {
        localmetrics.SetupTestJaeger(s.GetSuiteContext(), s.T())
        metricsHandler = metrics.Jaeger
    }

    var err error
    s.metrics, err = metrics.NewByType(s.GetSuiteContext(), metadata.BuildInfo(), metricsHandler)
    s.Require().Nil(err)
}

// SetupBackends sets up the test backends that are used for the tests. These need to be setup as embedded backends since
// scribe requires rpc addresses, so we employ some paraellism to speed up the test process.
//
// This can either be done per suite or per test. This is done per suite do to the cost of spinning up fake geth nodes.
func (s *TestClientSuite) SetupBackends(ctx context.Context) {
    // let's create 3 mock chains
    chainIDs := []uint64{1, 2, 3}

    // preallocate a slice for testbackends to the size of chainIDs
    // this way we can avoid non-deterministic order + needing to acquire/release a lock
    s.testBackends = make([]backends.SimulatedTestBackend, len(chainIDs))

    // TODO: can we use a waitgroup here instead?
    g, gCtx := errgroup.WithContext(ctx)
    for i, chainID := range chainIDs {
        pos := i           // get position of chain id in array
        chainID := chainID // capture func literal
        g.Go(func() error {
            // we need to use the embedded backend here, because the simulated backend doesn't support rpcs required by scribe
            backend := geth.NewEmbeddedBackendForChainID(ctx, s.T(), new(big.Int).SetUint64(chainID))

            // make sure we mine at least 1 block
            backend.GetFundedAccount(gCtx, big.NewInt(1000000000000000000))
            // add the backend to the list of backends
            s.testBackends[pos] = backend
            return nil
        })
    }

    // wait for all backends to be ready
    if err := g.Wait(); err != nil {
        s.T().Fatal(err)
    }
}

func (s *TestClientSuite) getHostURL(urlString string) string {
    parsedURL, err := url.Parse(urlString)
    s.Require().NoError(err)

    // Extract the protocol, hostname, and port
    protocol := parsedURL.Scheme
    hostname := parsedURL.Hostname()
    port := parsedURL.Port()

    // If the port is not specified, use the default port for the protocol
    if port == "" {
        if protocol == "http" {
            port = "80"
        } else if protocol == "https" {
            port = "443"
        }
    }

    // Construct the new URL string with just the protocol, hostname, and port
    newURLString := fmt.Sprintf("%s://%s:%s", protocol, hostname, port)
    return newURLString
}