status-im/status-go
2
0
Fork 0
mirror of https://github.com/status-im/status-go.git synced 2025-02-21 03:08:29 +00:00
Code Issues Projects Releases Wiki Activity

chore_: tests fix

Browse Source
This commit is contained in:
Dario Gabriel Lipicar 2025-02-04 11:44:18 -03:00 committed by dlipicar
parent 8c29a0cc1b
commit 3dfa6bd3fa
13 changed files with 194 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
api/backend_test.go
View File

@ -22,6 +22,7 @@ import (
gethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/appdatabase"
"github.com/status-im/status-go/connection"
"github.com/status-im/status-go/eth-node/crypto"
@ -1583,14 +1584,14 @@ func TestWalletConfigOnLoginAccount(t *testing.T) {
}
require.Equal(t, b.config.WalletConfig.InfuraAPIKey, infuraToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[MainnetChainID], alchemyEthereumMainnetToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[SepoliaChainID], alchemyEthereumSepoliaToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[ArbitrumChainID], alchemyArbitrumMainnetToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[ArbitrumSepoliaChainID], alchemyArbitrumSepoliaToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[OptimismChainID], alchemyOptimismMainnetToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[OptimismSepoliaChainID], alchemyOptimismSepoliaToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[BaseChainID], alchemyBaseMainnetToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[BaseSepoliaChainID], alchemyBaseSepoliaToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.MainnetChainID], alchemyEthereumMainnetToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.SepoliaChainID], alchemyEthereumSepoliaToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.ArbitrumChainID], alchemyArbitrumMainnetToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.ArbitrumSepoliaChainID], alchemyArbitrumSepoliaToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.OptimismChainID], alchemyOptimismMainnetToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.OptimismSepoliaChainID], alchemyOptimismSepoliaToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.BaseChainID], alchemyBaseMainnetToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.BaseSepoliaChainID], alchemyBaseSepoliaToken)
require.Equal(t, b.config.WalletConfig.RaribleMainnetAPIKey, raribleMainnetAPIKey)
require.Equal(t, b.config.WalletConfig.RaribleTestnetAPIKey, raribleTestnetAPIKey)

12
api/common/const.go Normal file
View File

@ -0,0 +1,12 @@
package common
const (
MainnetChainID uint64 = 1
SepoliaChainID uint64 = 11155111
OptimismChainID uint64 = 10
OptimismSepoliaChainID uint64 = 11155420
ArbitrumChainID uint64 = 42161
ArbitrumSepoliaChainID uint64 = 421614
BaseChainID uint64 = 8453
BaseSepoliaChainID uint64 = 84532
)

44
api/default_networks.go
View File

@ -4,23 +4,13 @@ import (
"fmt"
"strings"
"github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/params"
"github.com/status-im/status-go/params/networkhelper"
"github.com/status-im/status-go/protocol/requests"
)
const (
MainnetChainID uint64 = 1
SepoliaChainID uint64 = 11155111
OptimismChainID uint64 = 10
OptimismSepoliaChainID uint64 = 11155420
ArbitrumChainID uint64 = 42161
ArbitrumSepoliaChainID uint64 = 421614
BaseChainID uint64 = 8453
BaseSepoliaChainID uint64 = 84532
sntSymbol = "SNT"
sttSymbol = "STT"
// Host suffixes for providers
SmartProxyHostSuffix = "eth-rpc.status.im"
ProxyHostSuffix = "api.status.im"
@ -61,7 +51,7 @@ func smartProxyUrl(proxyHost, chainName, networkName string) string {
}
func mainnet(proxyHost, stageName string) params.Network {
const chainID = MainnetChainID
const chainID = common.MainnetChainID
const chainName = "ethereum"
const networkName = "mainnet"
@ -91,14 +81,14 @@ func mainnet(proxyHost, stageName string) params.Network {
IsTest: false,
Layer: 1,
Enabled: true,
RelatedChainID: SepoliaChainID,
RelatedChainID: common.SepoliaChainID,
IsActive: true,
IsDeactivatable: false,
}
}
func sepolia(proxyHost, stageName string) params.Network {
const chainID = SepoliaChainID
const chainID = common.SepoliaChainID
const chainName = "ethereum"
const networkName = "sepolia"
@ -128,14 +118,14 @@ func sepolia(proxyHost, stageName string) params.Network {
IsTest: true,
Layer: 1,
Enabled: true,
RelatedChainID: MainnetChainID,
RelatedChainID: common.MainnetChainID,
IsActive: true,
IsDeactivatable: false,
}
}
func optimism(proxyHost, stageName string) params.Network {
const chainID = OptimismChainID
const chainID = common.OptimismChainID
const chainName = "optimism"
const networkName = "mainnet"
@ -165,14 +155,14 @@ func optimism(proxyHost, stageName string) params.Network {
IsTest: false,
Layer: 2,
Enabled: true,
RelatedChainID: OptimismSepoliaChainID,
RelatedChainID: common.OptimismSepoliaChainID,
IsActive: true,
IsDeactivatable: true,
}
}
func optimismSepolia(proxyHost, stageName string) params.Network {
const chainID = OptimismSepoliaChainID
const chainID = common.OptimismSepoliaChainID
const chainName = "optimism"
const networkName = "sepolia"
@ -202,14 +192,14 @@ func optimismSepolia(proxyHost, stageName string) params.Network {
IsTest: true,
Layer: 2,
Enabled: false,
RelatedChainID: OptimismChainID,
RelatedChainID: common.OptimismChainID,
IsActive: true,
IsDeactivatable: true,
}
}
func arbitrum(proxyHost, stageName string) params.Network {
const chainID = ArbitrumChainID
const chainID = common.ArbitrumChainID
const chainName = "arbitrum"
const networkName = "mainnet"
@ -239,14 +229,14 @@ func arbitrum(proxyHost, stageName string) params.Network {
IsTest: false,
Layer: 2,
Enabled: true,
RelatedChainID: ArbitrumSepoliaChainID,
RelatedChainID: common.ArbitrumSepoliaChainID,
IsActive: true,
IsDeactivatable: true,
}
}
func arbitrumSepolia(proxyHost, stageName string) params.Network {
const chainID = ArbitrumSepoliaChainID
const chainID = common.ArbitrumSepoliaChainID
const chainName = "arbitrum"
const networkName = "sepolia"
@ -276,14 +266,14 @@ func arbitrumSepolia(proxyHost, stageName string) params.Network {
IsTest: true,
Layer: 2,
Enabled: false,
RelatedChainID: ArbitrumChainID,
RelatedChainID: common.ArbitrumChainID,
IsActive: true,
IsDeactivatable: true,
}
}
func base(proxyHost, stageName string) params.Network {
const chainID = BaseChainID
const chainID = common.BaseChainID
const chainName = "base"
const networkName = "mainnet"
@ -313,14 +303,14 @@ func base(proxyHost, stageName string) params.Network {
IsTest: false,
Layer: 2,
Enabled: true,
RelatedChainID: BaseSepoliaChainID,
RelatedChainID: common.BaseSepoliaChainID,
IsActive: true,
IsDeactivatable: true,
}
}
func baseSepolia(proxyHost, stageName string) params.Network {
const chainID = BaseSepoliaChainID
const chainID = common.BaseSepoliaChainID
const chainName = "base"
const networkName = "sepolia"
@ -350,7 +340,7 @@ func baseSepolia(proxyHost, stageName string) params.Network {
IsTest: true,
Layer: 2,
Enabled: false,
RelatedChainID: BaseChainID,
RelatedChainID: common.BaseChainID,
IsActive: true,
IsDeactivatable: true,
}

17
api/default_networks_test.go
View File

@ -4,6 +4,7 @@ import (
"strings"
"testing"
"github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/params"
"github.com/pkg/errors"
@ -30,14 +31,14 @@ func TestBuildDefaultNetworks(t *testing.T) {
for _, n := range actualNetworks {
var err error
switch n.ChainID {
case MainnetChainID:
case SepoliaChainID:
case OptimismChainID:
case OptimismSepoliaChainID:
case ArbitrumChainID:
case ArbitrumSepoliaChainID:
case BaseChainID:
case BaseSepoliaChainID:
case common.MainnetChainID:
case common.SepoliaChainID:
case common.OptimismChainID:
case common.OptimismSepoliaChainID:
case common.ArbitrumChainID:
case common.ArbitrumSepoliaChainID:
case common.BaseChainID:
case common.BaseSepoliaChainID:
default:
err = errors.Errorf("unexpected chain id: %d", n.ChainID)
}

17
api/defaults.go
View File

@ -7,6 +7,7 @@ import (
"path/filepath"
"github.com/status-im/status-go/account/generator"
"github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/eth-node/types"
"github.com/status-im/status-go/multiaccounts/settings"
"github.com/status-im/status-go/params"
@ -199,28 +200,28 @@ func buildWalletConfig(request *requests.WalletSecretsConfig, statusProxyEnabled
}
if request.AlchemyEthereumMainnetToken != "" {
walletConfig.AlchemyAPIKeys[MainnetChainID] = request.AlchemyEthereumMainnetToken
walletConfig.AlchemyAPIKeys[common.MainnetChainID] = request.AlchemyEthereumMainnetToken
}
if request.AlchemyEthereumSepoliaToken != "" {
walletConfig.AlchemyAPIKeys[SepoliaChainID] = request.AlchemyEthereumSepoliaToken
walletConfig.AlchemyAPIKeys[common.SepoliaChainID] = request.AlchemyEthereumSepoliaToken
}
if request.AlchemyArbitrumMainnetToken != "" {
walletConfig.AlchemyAPIKeys[ArbitrumChainID] = request.AlchemyArbitrumMainnetToken
walletConfig.AlchemyAPIKeys[common.ArbitrumChainID] = request.AlchemyArbitrumMainnetToken
}
if request.AlchemyArbitrumSepoliaToken != "" {
walletConfig.AlchemyAPIKeys[ArbitrumSepoliaChainID] = request.AlchemyArbitrumSepoliaToken
walletConfig.AlchemyAPIKeys[common.ArbitrumSepoliaChainID] = request.AlchemyArbitrumSepoliaToken
}
if request.AlchemyOptimismMainnetToken != "" {
walletConfig.AlchemyAPIKeys[OptimismChainID] = request.AlchemyOptimismMainnetToken
walletConfig.AlchemyAPIKeys[common.OptimismChainID] = request.AlchemyOptimismMainnetToken
}
if request.AlchemyOptimismSepoliaToken != "" {
walletConfig.AlchemyAPIKeys[OptimismSepoliaChainID] = request.AlchemyOptimismSepoliaToken
walletConfig.AlchemyAPIKeys[common.OptimismSepoliaChainID] = request.AlchemyOptimismSepoliaToken
}
if request.AlchemyBaseMainnetToken != "" {
walletConfig.AlchemyAPIKeys[BaseChainID] = request.AlchemyBaseMainnetToken
walletConfig.AlchemyAPIKeys[common.BaseChainID] = request.AlchemyBaseMainnetToken
}
if request.AlchemyBaseSepoliaToken != "" {
walletConfig.AlchemyAPIKeys[BaseSepoliaChainID] = request.AlchemyBaseSepoliaToken
walletConfig.AlchemyAPIKeys[common.BaseSepoliaChainID] = request.AlchemyBaseSepoliaToken
}
if request.StatusProxyMarketUser != "" {
walletConfig.StatusProxyMarketUser = request.StatusProxyMarketUser

38
params/networkhelper/provider_utils_test.go
View File

@ -11,7 +11,7 @@ import (
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/status-im/status-go/api"
api_common "github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/params"
"github.com/status-im/status-go/params/networkhelper"
"github.com/status-im/status-go/rpc/network/testutil"
@ -58,15 +58,15 @@ func TestMergeProvidersPreserveEnabledAndOrder(t *testing.T) {
func TestOverrideBasicAuth(t *testing.T) {
// Arrange: Create a sample list of networks with various provider types
networks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
*params.NewUserProvider(api.MainnetChainID, "Provider1", "https://userprovider.example.com", true),
*params.NewProxyProvider(api.MainnetChainID, "Provider2", "https://proxyprovider.example.com", true),
*params.NewEthRpcProxyProvider(api.MainnetChainID, "Provider3", "https://ethrpcproxy.example.com", true),
*testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
*params.NewUserProvider(api_common.MainnetChainID, "Provider1", "https://userprovider.example.com", true),
*params.NewProxyProvider(api_common.MainnetChainID, "Provider2", "https://proxyprovider.example.com", true),
*params.NewEthRpcProxyProvider(api_common.MainnetChainID, "Provider3", "https://ethrpcproxy.example.com", true),
}),
*testutil.CreateNetwork(api.OptimismChainID, "Optimism", []params.RpcProvider{
*params.NewDirectProvider(api.OptimismChainID, "Provider4", "https://directprovider.example.com", true),
*params.NewProxyProvider(api.OptimismChainID, "Provider5", "https://proxyprovider2.example.com", true),
*params.NewEthRpcProxyProvider(api.OptimismChainID, "Provider6", "https://ethrpcproxy2.example.com", true),
*testutil.CreateNetwork(api_common.OptimismChainID, "Optimism", []params.RpcProvider{
*params.NewDirectProvider(api_common.OptimismChainID, "Provider4", "https://directprovider.example.com", true),
*params.NewProxyProvider(api_common.OptimismChainID, "Provider5", "https://proxyprovider2.example.com", true),
*params.NewEthRpcProxyProvider(api_common.OptimismChainID, "Provider6", "https://ethrpcproxy2.example.com", true),
}),
}
networks[0].RpcProviders[1].Enabled = false
@ -131,14 +131,14 @@ func TestOverrideBasicAuth(t *testing.T) {
func TestOverrideDirectProvidersAuth(t *testing.T) {
// Create a sample list of networks with various provider types
networks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
*params.NewUserProvider(api.MainnetChainID, "Provider1", "https://user.example.com/", true),
*params.NewDirectProvider(api.MainnetChainID, "Provider2", "https://mainnet.infura.io/v3/", true),
*params.NewDirectProvider(api.MainnetChainID, "Provider3", "https://eth-archival.rpc.grove.city/v1/", true),
*testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
*params.NewUserProvider(api_common.MainnetChainID, "Provider1", "https://user.example.com/", true),
*params.NewDirectProvider(api_common.MainnetChainID, "Provider2", "https://mainnet.infura.io/v3/", true),
*params.NewDirectProvider(api_common.MainnetChainID, "Provider3", "https://eth-archival.rpc.grove.city/v1/", true),
}),
*testutil.CreateNetwork(api.OptimismChainID, "Optimism", []params.RpcProvider{
*params.NewDirectProvider(api.OptimismChainID, "Provider4", "https://optimism.infura.io/v3/", true),
*params.NewDirectProvider(api.OptimismChainID, "Provider5", "https://op.grove.city/v1/", true),
*testutil.CreateNetwork(api_common.OptimismChainID, "Optimism", []params.RpcProvider{
*params.NewDirectProvider(api_common.OptimismChainID, "Provider4", "https://optimism.infura.io/v3/", true),
*params.NewDirectProvider(api_common.OptimismChainID, "Provider5", "https://op.grove.city/v1/", true),
}),
}
@ -175,9 +175,9 @@ func TestOverrideDirectProvidersAuth(t *testing.T) {
}
func TestDeepCopyNetwork(t *testing.T) {
originalNetwork := testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
*params.NewUserProvider(api.MainnetChainID, "Provider1", "https://userprovider.example.com", true),
*params.NewDirectProvider(api.MainnetChainID, "Provider2", "https://mainnet.infura.io/v3/", true),
originalNetwork := testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
*params.NewUserProvider(api_common.MainnetChainID, "Provider1", "https://userprovider.example.com", true),
*params.NewDirectProvider(api_common.MainnetChainID, "Provider2", "https://mainnet.infura.io/v3/", true),
})
originalNetwork.TokenOverrides = []params.TokenOverride{

38
rpc/network/db/network_db_test.go
View File

@ -7,7 +7,7 @@ import (
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"github.com/status-im/status-go/api"
api_common "github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/appdatabase"
"github.com/status-im/status-go/params"
"github.com/status-im/status-go/rpc/network/db"
@ -98,15 +98,15 @@ func (s *NetworksPersistenceTestSuite) verifyNetworkDeletion(chainID uint64) {
// Tests
func (s *NetworksPersistenceTestSuite) TestAddAndGetNetworkWithProviders() {
network := testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", []params.RpcProvider{
testutil.CreateProvider(api.OptimismChainID, "Provider1", params.UserProviderType, true, "https://rpc.optimism.io"),
testutil.CreateProvider(api.OptimismChainID, "Provider2", params.EmbeddedProxyProviderType, false, "https://backup.optimism.io"),
network := testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", []params.RpcProvider{
testutil.CreateProvider(api_common.OptimismChainID, "Provider1", params.UserProviderType, true, "https://rpc.optimism.io"),
testutil.CreateProvider(api_common.OptimismChainID, "Provider2", params.EmbeddedProxyProviderType, false, "https://backup.optimism.io"),
})
s.addAndVerifyNetworks([]*params.Network{network})
}
func (s *NetworksPersistenceTestSuite) TestDeleteNetworkWithProviders() {
network := testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", DefaultProviders(api.OptimismChainID))
network := testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", DefaultProviders(api_common.OptimismChainID))
s.addAndVerifyNetworks([]*params.Network{network})
err := s.networksPersistence.DeleteNetwork(network.ChainID)
@ -116,13 +116,13 @@ func (s *NetworksPersistenceTestSuite) TestDeleteNetworkWithProviders() {
}
func (s *NetworksPersistenceTestSuite) TestUpdateNetworkAndProviders() {
network := testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", DefaultProviders(api.OptimismChainID))
network := testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", DefaultProviders(api_common.OptimismChainID))
s.addAndVerifyNetworks([]*params.Network{network})
// Update fields
network.ChainName = "Updated Optimism Mainnet"
network.RpcProviders = []params.RpcProvider{
testutil.CreateProvider(api.OptimismChainID, "UpdatedProvider", params.UserProviderType, true, "https://rpc.optimism.updated.io"),
testutil.CreateProvider(api_common.OptimismChainID, "UpdatedProvider", params.UserProviderType, true, "https://rpc.optimism.updated.io"),
}
s.addAndVerifyNetworks([]*params.Network{network})
@ -130,8 +130,8 @@ func (s *NetworksPersistenceTestSuite) TestUpdateNetworkAndProviders() {
func (s *NetworksPersistenceTestSuite) TestDeleteAllNetworks() {
networks := []*params.Network{
testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", DefaultProviders(api.MainnetChainID)),
testutil.CreateNetwork(api.SepoliaChainID, "Sepolia Testnet", DefaultProviders(api.SepoliaChainID)),
testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", DefaultProviders(api_common.MainnetChainID)),
testutil.CreateNetwork(api_common.SepoliaChainID, "Sepolia Testnet", DefaultProviders(api_common.SepoliaChainID)),
}
s.addAndVerifyNetworks(networks)
@ -145,11 +145,11 @@ func (s *NetworksPersistenceTestSuite) TestDeleteAllNetworks() {
func (s *NetworksPersistenceTestSuite) TestSetNetworks() {
initialNetworks := []*params.Network{
testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", DefaultProviders(api.MainnetChainID)),
testutil.CreateNetwork(api.SepoliaChainID, "Sepolia Testnet", DefaultProviders(api.SepoliaChainID)),
testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", DefaultProviders(api_common.MainnetChainID)),
testutil.CreateNetwork(api_common.SepoliaChainID, "Sepolia Testnet", DefaultProviders(api_common.SepoliaChainID)),
}
newNetworks := []*params.Network{
testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", DefaultProviders(api.OptimismChainID)),
testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", DefaultProviders(api_common.OptimismChainID)),
}
// Add initial networks
@ -159,25 +159,25 @@ func (s *NetworksPersistenceTestSuite) TestSetNetworks() {
s.addAndVerifyNetworks(newNetworks)
// Verify old networks are removed
s.verifyNetworkDeletion(api.MainnetChainID)
s.verifyNetworkDeletion(api.SepoliaChainID)
s.verifyNetworkDeletion(api_common.MainnetChainID)
s.verifyNetworkDeletion(api_common.SepoliaChainID)
}
func (s *NetworksPersistenceTestSuite) TestValidationForNetworksAndProviders() {
// Invalid Network: Missing required ChainName
invalidNetwork := testutil.CreateNetwork(api.MainnetChainID, "", DefaultProviders(api.MainnetChainID))
invalidNetwork := testutil.CreateNetwork(api_common.MainnetChainID, "", DefaultProviders(api_common.MainnetChainID))
// Invalid Provider: Missing URL
invalidProvider := params.RpcProvider{
Name: "InvalidProvider",
ChainID: api.MainnetChainID,
ChainID: api_common.MainnetChainID,
URL: "", // Invalid
Type: params.UserProviderType,
Enabled: true,
}
// Add invalid provider to a valid network
validNetworkWithInvalidProvider := testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", []params.RpcProvider{invalidProvider})
validNetworkWithInvalidProvider := testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", []params.RpcProvider{invalidProvider})
// Invalid networks and providers should fail validation
networksToValidate := []*params.Network{
@ -197,7 +197,7 @@ func (s *NetworksPersistenceTestSuite) TestValidationForNetworksAndProviders() {
}
func (s *NetworksPersistenceTestSuite) TestSetActive() {
network := testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", DefaultProviders(api.OptimismChainID))
network := testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", DefaultProviders(api_common.OptimismChainID))
s.addAndVerifyNetworks([]*params.Network{network})
// Deactivate the network
@ -222,7 +222,7 @@ func (s *NetworksPersistenceTestSuite) TestSetActive() {
}
func (s *NetworksPersistenceTestSuite) TestSetEnabled() {
network := testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", DefaultProviders(api.OptimismChainID))
network := testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", DefaultProviders(api_common.OptimismChainID))
s.addAndVerifyNetworks([]*params.Network{network})
// Disable the network

44
rpc/network/db/rpc_provider_db_test.go
View File

@ -7,7 +7,7 @@ import (
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"github.com/status-im/status-go/api"
api_common "github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/appdatabase"
"github.com/status-im/status-go/params"
"github.com/status-im/status-go/rpc/network/db"
@ -41,23 +41,23 @@ func TestRpcProviderPersistenceTestSuite(t *testing.T) {
// Test cases
func (s *RpcProviderPersistenceTestSuite) TestAddAndGetRpcProvider() {
provider := testutil.CreateProvider(api.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com")
provider := testutil.CreateProvider(api_common.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com")
err := s.rpcPersistence.AddRpcProvider(provider)
s.Require().NoError(err)
// Verify the added provider
providers, err := s.rpcPersistence.GetRpcProviders(api.MainnetChainID)
providers, err := s.rpcPersistence.GetRpcProviders(api_common.MainnetChainID)
s.Require().NoError(err)
testutil.CompareProvidersList(s.T(), []params.RpcProvider{provider}, providers)
}
func (s *RpcProviderPersistenceTestSuite) TestGetRpcProvidersByType() {
providers := []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "UserProvider1", params.UserProviderType, true, "https://provider1.example.com"),
testutil.CreateProvider(api.MainnetChainID, "EmbeddedDirect1", params.EmbeddedDirectProviderType, false, "https://provider2.example.com"),
testutil.CreateProvider(api.MainnetChainID, "UserProvider2", params.UserProviderType, false, "https://provider3.example.com"),
testutil.CreateProvider(api.MainnetChainID, "EmbeddedProxy1", params.EmbeddedProxyProviderType, true, "https://provider4.example.com"),
testutil.CreateProvider(api_common.MainnetChainID, "UserProvider1", params.UserProviderType, true, "https://provider1.example.com"),
testutil.CreateProvider(api_common.MainnetChainID, "EmbeddedDirect1", params.EmbeddedDirectProviderType, false, "https://provider2.example.com"),
testutil.CreateProvider(api_common.MainnetChainID, "UserProvider2", params.UserProviderType, false, "https://provider3.example.com"),
testutil.CreateProvider(api_common.MainnetChainID, "EmbeddedProxy1", params.EmbeddedProxyProviderType, true, "https://provider4.example.com"),
}
for _, provider := range providers {
@ -66,42 +66,42 @@ func (s *RpcProviderPersistenceTestSuite) TestGetRpcProvidersByType() {
}
// Verify by type
userProviders, err := s.rpcPersistence.GetRpcProvidersByType(api.MainnetChainID, params.UserProviderType)
userProviders, err := s.rpcPersistence.GetRpcProvidersByType(api_common.MainnetChainID, params.UserProviderType)
s.Require().NoError(err)
testutil.CompareProvidersList(s.T(), []params.RpcProvider{providers[0], providers[2]}, userProviders)
embeddedDirectProviders, err := s.rpcPersistence.GetRpcProvidersByType(api.MainnetChainID, params.EmbeddedDirectProviderType)
embeddedDirectProviders, err := s.rpcPersistence.GetRpcProvidersByType(api_common.MainnetChainID, params.EmbeddedDirectProviderType)
s.Require().NoError(err)
testutil.CompareProvidersList(s.T(), []params.RpcProvider{providers[1]}, embeddedDirectProviders)
embeddedProxyProviders, err := s.rpcPersistence.GetRpcProvidersByType(api.MainnetChainID, params.EmbeddedProxyProviderType)
embeddedProxyProviders, err := s.rpcPersistence.GetRpcProvidersByType(api_common.MainnetChainID, params.EmbeddedProxyProviderType)
s.Require().NoError(err)
testutil.CompareProvidersList(s.T(), []params.RpcProvider{providers[3]}, embeddedProxyProviders)
}
func (s *RpcProviderPersistenceTestSuite) TestDeleteRpcProviders() {
provider := testutil.CreateProvider(api.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com")
provider := testutil.CreateProvider(api_common.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com")
err := s.rpcPersistence.AddRpcProvider(provider)
s.Require().NoError(err)
err = s.rpcPersistence.DeleteRpcProviders(api.MainnetChainID)
err = s.rpcPersistence.DeleteRpcProviders(api_common.MainnetChainID)
s.Require().NoError(err)
// Verify deletion
providers, err := s.rpcPersistence.GetRpcProviders(api.MainnetChainID)
providers, err := s.rpcPersistence.GetRpcProviders(api_common.MainnetChainID)
s.Require().NoError(err)
s.Require().Empty(providers)
}
func (s *RpcProviderPersistenceTestSuite) TestUpdateRpcProvider() {
provider := testutil.CreateProvider(api.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com")
provider := testutil.CreateProvider(api_common.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com")
err := s.rpcPersistence.AddRpcProvider(provider)
s.Require().NoError(err)
// Retrieve provider to get the ID
providers, err := s.rpcPersistence.GetRpcProviders(api.MainnetChainID)
providers, err := s.rpcPersistence.GetRpcProviders(api_common.MainnetChainID)
s.Require().NoError(err)
s.Require().Len(providers, 1)
@ -113,15 +113,15 @@ func (s *RpcProviderPersistenceTestSuite) TestUpdateRpcProvider() {
s.Require().NoError(err)
// Verify update
updatedProviders, err := s.rpcPersistence.GetRpcProviders(api.MainnetChainID)
updatedProviders, err := s.rpcPersistence.GetRpcProviders(api_common.MainnetChainID)
s.Require().NoError(err)
testutil.CompareProvidersList(s.T(), []params.RpcProvider{provider}, updatedProviders)
}
func (s *RpcProviderPersistenceTestSuite) TestSetRpcProviders() {
initialProviders := []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com"),
testutil.CreateProvider(api.MainnetChainID, "Provider2", params.EmbeddedDirectProviderType, false, "https://provider2.example.com"),
testutil.CreateProvider(api_common.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com"),
testutil.CreateProvider(api_common.MainnetChainID, "Provider2", params.EmbeddedDirectProviderType, false, "https://provider2.example.com"),
}
for _, provider := range initialProviders {
@ -130,15 +130,15 @@ func (s *RpcProviderPersistenceTestSuite) TestSetRpcProviders() {
}
newProviders := []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "NewProvider1", params.UserProviderType, true, "https://newprovider1.example.com"),
testutil.CreateProvider(api.MainnetChainID, "NewProvider2", params.EmbeddedProxyProviderType, true, "https://newprovider2.example.com"),
testutil.CreateProvider(api_common.MainnetChainID, "NewProvider1", params.UserProviderType, true, "https://newprovider1.example.com"),
testutil.CreateProvider(api_common.MainnetChainID, "NewProvider2", params.EmbeddedProxyProviderType, true, "https://newprovider2.example.com"),
}
err := s.rpcPersistence.SetRpcProviders(api.MainnetChainID, newProviders)
err := s.rpcPersistence.SetRpcProviders(api_common.MainnetChainID, newProviders)
s.Require().NoError(err)
// Verify replacement
providers, err := s.rpcPersistence.GetRpcProviders(api.MainnetChainID)
providers, err := s.rpcPersistence.GetRpcProviders(api_common.MainnetChainID)
s.Require().NoError(err)
testutil.CompareProvidersList(s.T(), newProviders, providers)
}

105
rpc/network/network_test.go
View File

@ -4,8 +4,7 @@ import (
"database/sql"
"testing"
"github.com/status-im/status-go/api"
api_common "github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/appdatabase"
"github.com/status-im/status-go/params"
"github.com/status-im/status-go/params/networkhelper"
@ -35,23 +34,23 @@ func (s *NetworkManagerTestSuite) SetupTest() {
// Use testutil to initialize networks
initNetworks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "Infura Mainnet", params.UserProviderType, true, "https://mainnet.infura.io"),
*testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api_common.MainnetChainID, "Infura Mainnet", params.UserProviderType, true, "https://mainnet.infura.io"),
}),
*testutil.CreateNetwork(api.SepoliaChainID, "Sepolia Testnet", []params.RpcProvider{
testutil.CreateProvider(api.SepoliaChainID, "Infura Sepolia", params.UserProviderType, true, "https://sepolia.infura.io"),
*testutil.CreateNetwork(api_common.SepoliaChainID, "Sepolia Testnet", []params.RpcProvider{
testutil.CreateProvider(api_common.SepoliaChainID, "Infura Sepolia", params.UserProviderType, true, "https://sepolia.infura.io"),
}),
*testutil.CreateNetwork(api.OptimismChainID, "Optimistic Ethereum", []params.RpcProvider{
testutil.CreateProvider(api.OptimismChainID, "Infura Optimism", params.UserProviderType, true, "https://optimism.infura.io"),
*testutil.CreateNetwork(api_common.OptimismChainID, "Optimistic Ethereum", []params.RpcProvider{
testutil.CreateProvider(api_common.OptimismChainID, "Infura Optimism", params.UserProviderType, true, "https://optimism.infura.io"),
}),
*testutil.CreateNetwork(api.OptimismSepoliaChainID, "Optimistic Sepolia", []params.RpcProvider{
testutil.CreateProvider(api.OptimismSepoliaChainID, "Infura Optimism Sepolia", params.UserProviderType, true, "https://optimism-sepolia.infura.io"),
*testutil.CreateNetwork(api_common.OptimismSepoliaChainID, "Optimistic Sepolia", []params.RpcProvider{
testutil.CreateProvider(api_common.OptimismSepoliaChainID, "Infura Optimism Sepolia", params.UserProviderType, true, "https://optimism-sepolia.infura.io"),
}),
*testutil.CreateNetwork(api.BaseChainID, "Base", []params.RpcProvider{
testutil.CreateProvider(api.BaseChainID, "Infura Base", params.UserProviderType, true, "https://base.infura.io"),
*testutil.CreateNetwork(api_common.BaseChainID, "Base", []params.RpcProvider{
testutil.CreateProvider(api_common.BaseChainID, "Infura Base", params.UserProviderType, true, "https://base.infura.io"),
}),
*testutil.CreateNetwork(api.BaseSepoliaChainID, "Base Sepolia", []params.RpcProvider{
testutil.CreateProvider(api.BaseSepoliaChainID, "Infura Base Sepolia", params.UserProviderType, true, "https://base-sepolia.infura.io"),
*testutil.CreateNetwork(api_common.BaseSepoliaChainID, "Base Sepolia", []params.RpcProvider{
testutil.CreateProvider(api_common.BaseSepoliaChainID, "Infura Base Sepolia", params.UserProviderType, true, "https://base-sepolia.infura.io"),
}),
}
// Make "Ethereum Mainnet" network not deactivatable
@ -92,14 +91,14 @@ func (s *NetworkManagerTestSuite) assertDbNetworks(expectedNetworks []params.Net
func (s *NetworkManagerTestSuite) TestUserAddsCustomProviders() {
// Adding custom providers
customProviders := []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "CustomProvider1", params.UserProviderType, true, "https://custom1.example.com"),
testutil.CreateProvider(api.MainnetChainID, "CustomProvider2", params.UserProviderType, false, "https://custom2.example.com"),
testutil.CreateProvider(api_common.MainnetChainID, "CustomProvider1", params.UserProviderType, true, "https://custom1.example.com"),
testutil.CreateProvider(api_common.MainnetChainID, "CustomProvider2", params.UserProviderType, false, "https://custom2.example.com"),
}
err := s.manager.SetUserRpcProviders(api.MainnetChainID, customProviders)
err := s.manager.SetUserRpcProviders(api_common.MainnetChainID, customProviders)
s.Require().NoError(err)
// Assert providers
foundNetwork := s.manager.Find(api.MainnetChainID)
foundNetwork := s.manager.Find(api_common.MainnetChainID)
s.Require().NotNil(foundNetwork)
expectedProviders := append(customProviders, networkhelper.GetEmbeddedProviders(foundNetwork.RpcProviders)...)
testutil.CompareProvidersList(s.T(), expectedProviders, foundNetwork.RpcProviders)
@ -108,23 +107,23 @@ func (s *NetworkManagerTestSuite) TestUserAddsCustomProviders() {
func (s *NetworkManagerTestSuite) TestInitNetworksKeepsUserProviders() {
// Add custom providers
customProviders := []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "CustomProvider1", params.UserProviderType, true, "https://custom1.example.com"),
testutil.CreateProvider(api.MainnetChainID, "CustomProvider2", params.UserProviderType, false, "https://custom2.example.com"),
testutil.CreateProvider(api_common.MainnetChainID, "CustomProvider1", params.UserProviderType, true, "https://custom1.example.com"),
testutil.CreateProvider(api_common.MainnetChainID, "CustomProvider2", params.UserProviderType, false, "https://custom2.example.com"),
}
err := s.manager.SetUserRpcProviders(api.MainnetChainID, customProviders)
err := s.manager.SetUserRpcProviders(api_common.MainnetChainID, customProviders)
s.Require().NoError(err)
// Re-initialize networks
initNetworks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"),
*testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api_common.MainnetChainID, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"),
}),
}
err = s.manager.InitEmbeddedNetworks(initNetworks)
s.Require().NoError(err)
// Check that custom providers are retained
foundNetwork := s.manager.Find(api.MainnetChainID)
foundNetwork := s.manager.Find(api_common.MainnetChainID)
s.Require().NotNil(foundNetwork)
expectedProviders := append(customProviders, networkhelper.GetEmbeddedProviders(initNetworks[0].RpcProviders)...)
testutil.CompareProvidersList(s.T(), expectedProviders, foundNetwork.RpcProviders)
@ -136,8 +135,8 @@ func (s *NetworkManagerTestSuite) TestInitNetworksDoesNotSaveEmbeddedProviders()
// Re-initialize networks
initNetworks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"),
*testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api_common.MainnetChainID, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"),
}),
}
err := s.manager.InitEmbeddedNetworks(initNetworks)
@ -153,8 +152,8 @@ func (s *NetworkManagerTestSuite) TestInitNetworksDoesNotSaveEmbeddedProviders()
func (s *NetworkManagerTestSuite) TestInitEmbeddedNetworks() {
// Re-initialize networks
initNetworks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"),
*testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api_common.MainnetChainID, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"),
}),
}
expectedProviders := networkhelper.GetEmbeddedProviders(initNetworks[0].RpcProviders)
@ -164,7 +163,7 @@ func (s *NetworkManagerTestSuite) TestInitEmbeddedNetworks() {
// functor tests if embedded providers are present in the networks
expectEmbeddedProviders := func(networks []*params.Network) {
for _, network := range networks {
if network.ChainID == api.MainnetChainID {
if network.ChainID == api_common.MainnetChainID {
storedEmbeddedProviders := networkhelper.GetEmbeddedProviders(network.RpcProviders)
testutil.CompareProvidersList(s.T(), expectedProviders, storedEmbeddedProviders)
}
@ -190,11 +189,11 @@ func (s *NetworkManagerTestSuite) TestInitEmbeddedNetworks() {
combinedNetworks, err := s.manager.GetCombinedNetworks()
s.Require().NoError(err)
for _, combinedNetwork := range combinedNetworks {
if combinedNetwork.Test != nil && combinedNetwork.Test.ChainID == api.MainnetChainID {
if combinedNetwork.Test != nil && combinedNetwork.Test.ChainID == api_common.MainnetChainID {
storedEmbeddedProviders := networkhelper.GetEmbeddedProviders(combinedNetwork.Test.RpcProviders)
testutil.CompareProvidersList(s.T(), expectedProviders, storedEmbeddedProviders)
}
if combinedNetwork.Prod != nil && combinedNetwork.Prod.ChainID == api.MainnetChainID {
if combinedNetwork.Prod != nil && combinedNetwork.Prod.ChainID == api_common.MainnetChainID {
storedEmbeddedProviders := networkhelper.GetEmbeddedProviders(combinedNetwork.Prod.RpcProviders)
testutil.CompareProvidersList(s.T(), expectedProviders, storedEmbeddedProviders)
}
@ -208,14 +207,14 @@ func (s *NetworkManagerTestSuite) TestInitEmbeddedNetworks() {
func (s *NetworkManagerTestSuite) TestLegacyFieldPopulation() {
// Create initial test networks with various providers
initNetworks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "DirectProvider1", params.EmbeddedDirectProviderType, true, "https://direct1.ethereum.io"),
testutil.CreateProvider(api.MainnetChainID, "DirectProvider2", params.EmbeddedDirectProviderType, true, "https://direct2.ethereum.io"),
testutil.CreateProvider(api.MainnetChainID, "ProxyProvider1", params.EmbeddedProxyProviderType, true, "https://proxy1.ethereum.io"),
testutil.CreateProvider(api.MainnetChainID, "ProxyProvider2", params.EmbeddedProxyProviderType, true, "https://proxy2.ethereum.io"),
testutil.CreateProvider(api.MainnetChainID, "ProxyProvider3", params.EmbeddedProxyProviderType, true, "https://proxy3.ethereum.io"),
testutil.CreateProvider(api.MainnetChainID, "UserProvider1", params.UserProviderType, true, "https://user1.ethereum.io"),
testutil.CreateProvider(api.MainnetChainID, "UserProvider2", params.UserProviderType, true, "https://user2.ethereum.io"),
*testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api_common.MainnetChainID, "DirectProvider1", params.EmbeddedDirectProviderType, true, "https://direct1.ethereum.io"),
testutil.CreateProvider(api_common.MainnetChainID, "DirectProvider2", params.EmbeddedDirectProviderType, true, "https://direct2.ethereum.io"),
testutil.CreateProvider(api_common.MainnetChainID, "ProxyProvider1", params.EmbeddedProxyProviderType, true, "https://proxy1.ethereum.io"),
testutil.CreateProvider(api_common.MainnetChainID, "ProxyProvider2", params.EmbeddedProxyProviderType, true, "https://proxy2.ethereum.io"),
testutil.CreateProvider(api_common.MainnetChainID, "ProxyProvider3", params.EmbeddedProxyProviderType, true, "https://proxy3.ethereum.io"),
testutil.CreateProvider(api_common.MainnetChainID, "UserProvider1", params.UserProviderType, true, "https://user1.ethereum.io"),
testutil.CreateProvider(api_common.MainnetChainID, "UserProvider2", params.UserProviderType, true, "https://user2.ethereum.io"),
}),
}
@ -244,10 +243,10 @@ func (s *NetworkManagerTestSuite) TestLegacyFieldPopulation() {
func (s *NetworkManagerTestSuite) TestLegacyFieldPopulationWithoutUserProviders() {
// Create a test network with only EmbeddedDirect and EmbeddedProxy providers
initNetworks := []params.Network{
*testutil.CreateNetwork(api.SepoliaChainID, "Sepolia Testnet", []params.RpcProvider{
testutil.CreateProvider(api.SepoliaChainID, "DirectProvider1", params.EmbeddedDirectProviderType, true, "https://direct1.sepolia.io"),
testutil.CreateProvider(api.SepoliaChainID, "ProxyProvider1", params.EmbeddedProxyProviderType, true, "https://proxy1.sepolia.io"),
testutil.CreateProvider(api.SepoliaChainID, "ProxyProvider2", params.EmbeddedProxyProviderType, true, "https://proxy2.sepolia.io"),
*testutil.CreateNetwork(api_common.SepoliaChainID, "Sepolia Testnet", []params.RpcProvider{
testutil.CreateProvider(api_common.SepoliaChainID, "DirectProvider1", params.EmbeddedDirectProviderType, true, "https://direct1.sepolia.io"),
testutil.CreateProvider(api_common.SepoliaChainID, "ProxyProvider1", params.EmbeddedProxyProviderType, true, "https://proxy1.sepolia.io"),
testutil.CreateProvider(api_common.SepoliaChainID, "ProxyProvider2", params.EmbeddedProxyProviderType, true, "https://proxy2.sepolia.io"),
}),
}
@ -303,25 +302,25 @@ func (s *NetworkManagerTestSuite) TestSetActive() {
var n *params.Network
// Check that the "Base" network is active by default
n = s.manager.Find(api.BaseChainID)
n = s.manager.Find(api_common.BaseChainID)
s.Require().NotNil(n)
s.True(n.IsActive)
// Set the "Base" network to inactive
err = s.manager.SetActive(api.BaseChainID, false)
err = s.manager.SetActive(api_common.BaseChainID, false)
s.Require().NoError(err)
// Verify the network was set to inactive
n = s.manager.Find(api.BaseChainID)
n = s.manager.Find(api_common.BaseChainID)
s.Require().NotNil(n)
s.False(n.IsActive)
// Set the "Base" network to active
err = s.manager.SetActive(api.BaseChainID, true)
err = s.manager.SetActive(api_common.BaseChainID, true)
s.Require().NoError(err)
// Verify the network was set to active
n = s.manager.Find(api.BaseChainID)
n = s.manager.Find(api_common.BaseChainID)
s.Require().NotNil(n)
s.True(n.IsActive)
}
@ -331,11 +330,11 @@ func (s *NetworkManagerTestSuite) TestSetActiveNotDeactivatable() {
var n *params.Network
// Try to set Ethereum Mainnet to inactive (should fail)
err = s.manager.SetActive(api.MainnetChainID, false)
err = s.manager.SetActive(api_common.MainnetChainID, false)
s.Require().Error(err)
// Verify the network was not set to inactive
n = s.manager.Find(api.MainnetChainID)
n = s.manager.Find(api_common.MainnetChainID)
s.Require().NotNil(n)
s.True(n.IsActive)
}
@ -350,16 +349,16 @@ func (s *NetworkManagerTestSuite) TestSetActiveMaxNumberOfActiveNetworks() {
s.Require().Len(activeNetworks, network.MaxActiveNetworks)
// Check that the "Optimistic Ethereum" network is inactive by default
n = s.manager.Find(api.OptimismChainID)
n = s.manager.Find(api_common.OptimismChainID)
s.Require().NotNil(n)
s.False(n.IsActive)
// Try to set the "Optimistic Ethereum" network to active (should fail due to number networks active)
err = s.manager.SetActive(api.OptimismChainID, true)
err = s.manager.SetActive(api_common.OptimismChainID, true)
s.Require().Error(err)
// Verify the network was not set to active
n = s.manager.Find(api.OptimismChainID)
n = s.manager.Find(api_common.OptimismChainID)
s.Require().NotNil(n)
s.False(n.IsActive)
}

4
rpc/network/testutil/testutil.go
View File

@ -3,7 +3,7 @@ package testutil
import (
"github.com/stretchr/testify/require"
"github.com/status-im/status-go/api"
api_common "github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/params"
)
@ -38,7 +38,7 @@ func CreateNetwork(chainID uint64, chainName string, providers []params.RpcProvi
Enabled: true,
ChainColor: "#E90101",
ShortName: "eth",
RelatedChainID: api.OptimismSepoliaChainID,
RelatedChainID: api_common.OptimismSepoliaChainID,
RpcProviders: providers,
IsActive: true,
IsDeactivatable: true,

22
services/connector/commands/test_helpers.go
View File

@ -14,6 +14,7 @@ import (
"github.com/status-im/status-go/params"
mock_rpcclient "github.com/status-im/status-go/rpc/mock/client"
"github.com/status-im/status-go/rpc/network"
network_testutil "github.com/status-im/status-go/rpc/network/testutil"
persistence "github.com/status-im/status-go/services/connector/database"
walletCommon "github.com/status-im/status-go/services/wallet/common"
"github.com/status-im/status-go/signal"
@ -69,18 +70,15 @@ func setupCommand(t *testing.T, method string) (state testState, close func()) {
networkManager := network.NewManager(state.db, nil, nil, nil)
require.NotNil(t, networkManager)
err := networkManager.InitEmbeddedNetworks([]params.Network{
{
ChainID: walletCommon.EthereumMainnet,
ChainName: "Ethereum Mainnet",
Layer: 1,
},
{
ChainID: walletCommon.OptimismMainnet,
ChainName: "Optimism Mainnet",
Layer: 1,
},
})
initNetworks := []params.Network{
*network_testutil.CreateNetwork(walletCommon.EthereumMainnet, "Ethereum Mainnet", []params.RpcProvider{
network_testutil.CreateProvider(walletCommon.EthereumMainnet, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"),
}),
*network_testutil.CreateNetwork(walletCommon.OptimismMainnet, "Optimism Mainnet", []params.RpcProvider{
network_testutil.CreateProvider(walletCommon.OptimismMainnet, "Optimism Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.optimism.io"),
}),
}
err := networkManager.InitEmbeddedNetworks(initNetworks)
require.NoError(t, err)
state.handler = NewClientSideHandler(state.db)

22
services/connector/test_helpers.go
View File

@ -14,6 +14,7 @@ import (
"github.com/status-im/status-go/params"
mock_rpcclient "github.com/status-im/status-go/rpc/mock/client"
"github.com/status-im/status-go/rpc/network"
network_testutil "github.com/status-im/status-go/rpc/network/testutil"
walletCommon "github.com/status-im/status-go/services/wallet/common"
"github.com/status-im/status-go/t/helpers"
"github.com/status-im/status-go/walletdatabase"
@ -73,18 +74,15 @@ func setupTests(t *testing.T) (state testState, close func()) {
networkManager := network.NewManager(state.db, nil, nil, nil)
require.NotNil(t, networkManager)
err = networkManager.InitEmbeddedNetworks([]params.Network{
{
ChainID: walletCommon.EthereumMainnet,
ChainName: "Ethereum Mainnet",
Layer: 1,
},
{
ChainID: walletCommon.OptimismMainnet,
ChainName: "Optimism Mainnet",
Layer: 1,
},
})
initNetworks := []params.Network{
*network_testutil.CreateNetwork(walletCommon.EthereumMainnet, "Ethereum Mainnet", []params.RpcProvider{
network_testutil.CreateProvider(walletCommon.EthereumMainnet, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"),
}),
*network_testutil.CreateNetwork(walletCommon.OptimismMainnet, "Optimism Mainnet", []params.RpcProvider{
network_testutil.CreateProvider(walletCommon.OptimismMainnet, "Optimism Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.optimism.io"),
}),
}
err = networkManager.InitEmbeddedNetworks(initNetworks)
require.NoError(t, err)
state.rpcClient.EXPECT().GetNetworkManager().AnyTimes().Return(networkManager)

17
services/wallet/api_test.go
View File

@ -10,6 +10,7 @@ import (
"time"
"github.com/status-im/status-go/params/networkhelper"
"github.com/status-im/status-go/rpc/network/testutil"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/event"
@ -136,20 +137,10 @@ func TestAPI_GetAddressDetails(t *testing.T) {
defer serverWith1SecDelay.Close()
networks := []params.Network{
{
ChainID: chainID,
ChainName: "Ethereum Mainnet",
RpcProviders: []params.RpcProvider{
{
ChainID: chainID,
Name: "Test Provider",
URL: serverWith1SecDelay.URL + "/nodefleet/",
Type: params.EmbeddedProxyProviderType,
Enabled: true,
AuthType: params.NoAuth,
},
},
*testutil.CreateNetwork(chainID, "Ethereum Mainnet", []params.RpcProvider{
*params.NewProxyProvider(chainID, "Test Provider", serverWith1SecDelay.URL+"/nodefleet/", false),
},
),
}
networks = networkhelper.OverrideBasicAuth(networks, params.EmbeddedProxyProviderType, true, gofakeit.Username(), gofakeit.LetterN(5))