github.com/Finschia/ostracon@v1.1.5/rpc/core/net_test.go (about)

     1  package core
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  	"github.com/stretchr/testify/require"
     8  
     9  	cfg "github.com/Finschia/ostracon/config"
    10  	"github.com/Finschia/ostracon/libs/log"
    11  	"github.com/Finschia/ostracon/p2p"
    12  	rpctypes "github.com/Finschia/ostracon/rpc/jsonrpc/types"
    13  )
    14  
    15  func TestUnsafeDialSeeds(t *testing.T) {
    16  	sw := p2p.MakeSwitch(cfg.DefaultP2PConfig(), 1, "testing", "123.123.123",
    17  		func(n int, sw *p2p.Switch, config *cfg.P2PConfig) *p2p.Switch { return sw })
    18  	err := sw.Start()
    19  	require.NoError(t, err)
    20  	t.Cleanup(func() {
    21  		if err := sw.Stop(); err != nil {
    22  			t.Error(err)
    23  		}
    24  	})
    25  
    26  	env.Logger = log.TestingLogger()
    27  	env.P2PPeers = sw
    28  
    29  	testCases := []struct {
    30  		seeds []string
    31  		isErr bool
    32  	}{
    33  		{[]string{}, true},
    34  		{[]string{"d51fb70907db1c6c2d5237e78379b25cf1a37ab4@127.0.0.1:41198"}, false},
    35  		{[]string{"127.0.0.1:41198"}, true},
    36  	}
    37  
    38  	for _, tc := range testCases {
    39  		res, err := UnsafeDialSeeds(&rpctypes.Context{}, tc.seeds)
    40  		if tc.isErr {
    41  			assert.Error(t, err)
    42  		} else {
    43  			assert.NoError(t, err)
    44  			assert.NotNil(t, res)
    45  		}
    46  	}
    47  }
    48  
    49  func TestUnsafeDialPeers(t *testing.T) {
    50  	sw := p2p.MakeSwitch(cfg.DefaultP2PConfig(), 1, "testing", "123.123.123",
    51  		func(n int, sw *p2p.Switch, config *cfg.P2PConfig) *p2p.Switch { return sw })
    52  	sw.SetAddrBook(&p2p.AddrBookMock{
    53  		Addrs:        make(map[string]struct{}),
    54  		OurAddrs:     make(map[string]struct{}),
    55  		PrivateAddrs: make(map[string]struct{}),
    56  	})
    57  	err := sw.Start()
    58  	require.NoError(t, err)
    59  	t.Cleanup(func() {
    60  		if err := sw.Stop(); err != nil {
    61  			t.Error(err)
    62  		}
    63  	})
    64  
    65  	env.Logger = log.TestingLogger()
    66  	env.P2PPeers = sw
    67  
    68  	testCases := []struct {
    69  		peers                               []string
    70  		persistence, unconditional, private bool
    71  		isErr                               bool
    72  	}{
    73  		{[]string{}, false, false, false, true},
    74  		{[]string{"d51fb70907db1c6c2d5237e78379b25cf1a37ab4@127.0.0.1:41198"}, true, true, true, false},
    75  		{[]string{"127.0.0.1:41198"}, true, true, false, true},
    76  	}
    77  
    78  	for _, tc := range testCases {
    79  		res, err := UnsafeDialPeers(&rpctypes.Context{}, tc.peers, tc.persistence, tc.unconditional, tc.private)
    80  		if tc.isErr {
    81  			assert.Error(t, err)
    82  		} else {
    83  			assert.NoError(t, err)
    84  			assert.NotNil(t, res)
    85  		}
    86  	}
    87  }
    88  
    89  func TestGenesis(t *testing.T) {
    90  	env = &Environment{}
    91  
    92  	// success
    93  	env.genChunks = []string{}
    94  	res, err := Genesis(&rpctypes.Context{})
    95  	assert.NoError(t, err)
    96  	assert.NotNil(t, res)
    97  
    98  	// error
    99  	env.genChunks = []string{"", ""}
   100  	res, err = Genesis(&rpctypes.Context{})
   101  	assert.Error(t, err)
   102  	assert.Equal(t, "genesis response is large, please use the genesis_chunked API instead", err.Error())
   103  	assert.Nil(t, res)
   104  }
   105  
   106  func TestGenesisChunked(t *testing.T) {
   107  	env = &Environment{}
   108  
   109  	// success
   110  	env.genChunks = []string{""}
   111  	chunk := uint(0)
   112  	res, err := GenesisChunked(&rpctypes.Context{}, chunk)
   113  	assert.NoError(t, err)
   114  	assert.NotNil(t, res)
   115  
   116  	//
   117  	// errors
   118  	//
   119  
   120  	env.genChunks = nil
   121  	chunk = uint(0)
   122  	res, err = GenesisChunked(&rpctypes.Context{}, chunk)
   123  	assert.Error(t, err)
   124  	assert.Equal(t, "service configuration error, genesis chunks are not initialized", err.Error())
   125  	assert.Nil(t, res)
   126  
   127  	env.genChunks = []string{}
   128  	chunk = uint(0)
   129  	res, err = GenesisChunked(&rpctypes.Context{}, chunk)
   130  	assert.Error(t, err)
   131  	assert.Equal(t, "service configuration error, there are no chunks", err.Error())
   132  	assert.Nil(t, res)
   133  
   134  	env.genChunks = []string{""}
   135  	chunk = uint(1)
   136  	res, err = GenesisChunked(&rpctypes.Context{}, chunk)
   137  	assert.Error(t, err)
   138  	assert.Contains(t, err.Error(), "there are ")
   139  	assert.Contains(t, err.Error(), " is invalid")
   140  	assert.Nil(t, res)
   141  }