synapsecns/sanguine

package manager_test

import (
    "context"
    "github.com/brianvoe/gofakeit/v6"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/common/compiler"
    "github.com/ethereum/go-ethereum/core/types"
    backendMocks "github.com/synapsecns/sanguine/ethergo/backends/mocks"
    contractMocks "github.com/synapsecns/sanguine/ethergo/contracts/mocks"
    deployerMocks "github.com/synapsecns/sanguine/ethergo/deployer/mocks"
    "math/big"
    "reflect"
    "testing"

    "github.com/stretchr/testify/mock"

    . "github.com/stretchr/testify/assert"
    "github.com/synapsecns/sanguine/ethergo/contracts"
    "github.com/synapsecns/sanguine/ethergo/manager"
)

var mockCtx = mock.AnythingOfType(reflect.TypeOf(context.Background()).String())

func TestDeployerManager_Get(t *testing.T) {
    backend := &backendMocks.SimulatedTestBackend{}
    backend.On("GetBigChainID").Return(big.NewInt(1))

    mgr := manager.NewDeployerManager(t)

    contractRegistry := new(deployerMocks.ContractRegistry)

    contractType1 := makeContractType()
    contractType2 := makeContractType()

    deployedContract1 := makeDeployedContract()
    deployedContract2 := makeDeployedContract()

    contractRegistry.On("Get", mockCtx, contractType1).Return(deployedContract1, nil)
    contractRegistry.On("Get", mockCtx, contractType2).Return(deployedContract2, nil)

    mgr.SetContractRegistry(backend, contractRegistry)

    dc2 := mgr.Get(context.Background(), backend, contractType2)
    Equal(t, dc2, deployedContract2)

    dc1 := mgr.Get(context.Background(), backend, contractType1)
    Equal(t, dc1, deployedContract1)
}

func TestDeployManager(t *testing.T) {
    mgr := manager.NewDeployerManager(t)
    Equal(t, mgr.T(), t)

    Panics(t, func() {
        mgr.SetT(nil)
    })
}

func makeContractType() contracts.ContractType {
    contractType := new(contractMocks.ContractType)
    contractType.On("Name").Return(gofakeit.Word())
    contractType.On("ID").Return(int(gofakeit.Int64()))
    contractType.On("ContractInfo").Return(&compiler.Contract{})
    contractType.On("ContractName").Return(gofakeit.Word())
    return contractType
}

func makeDeployedContract() contracts.DeployedContract {
    owner := common.BigToAddress(new(big.Int).SetUint64(gofakeit.Uint64()))

    deployedContract := new(contractMocks.DeployedContract)
    deployedContract.On("Address").Return(common.BigToAddress(new(big.Int).SetUint64(gofakeit.Uint64())))
    deployedContract.On("ContractHandle").Return("")
    deployedContract.On("Owner").Return(owner)
    address := common.BigToAddress(new(big.Int).SetUint64(gofakeit.Uint64()))
    deployedContract.On("DeployTx").Return(types.NewTx(&types.LegacyTx{
        Nonce:    gofakeit.Uint64(),
        GasPrice: big.NewInt(gofakeit.Int64()),
        Gas:      gofakeit.Uint64(),
        To:       &address,
        Value:    big.NewInt(gofakeit.Int64()),
        Data:     []byte(gofakeit.Word()),
        V:        new(big.Int).SetUint64(gofakeit.Uint64()),
        R:        new(big.Int).SetUint64(gofakeit.Uint64()),
        S:        new(big.Int).SetUint64(gofakeit.Uint64()),
    }))
    deployedContract.On("ChainID").Return(big.NewInt(gofakeit.Int64()))
    deployedContract.On("OwnerPtr").Return(owner)
    return deployedContract
}

func TestGetContractRegistry(t *testing.T) {
    t.Skip("TODO")
}

func TestGetDeployedContracts(t *testing.T) {
    t.Skip("TODO")
}

func TestAssertDependniesCorrect(t *testing.T) {
    t.Skip("TODO")
}