github.com/hechain20/hechain@v0.0.0-20220316014945-b544036ba106/core/deliverservice/config_test.go (about)

     1  /*
     2  Copyright hechain. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package deliverservice_test
     8  
     9  import (
    10  	"bytes"
    11  	"io/ioutil"
    12  	"os"
    13  	"path/filepath"
    14  	"testing"
    15  	"time"
    16  
    17  	"github.com/stretchr/testify/require"
    18  
    19  	"github.com/hechain20/hechain/core/deliverservice"
    20  	"github.com/hechain20/hechain/internal/pkg/comm"
    21  	"github.com/spf13/viper"
    22  )
    23  
    24  func TestSecureOptsConfig(t *testing.T) {
    25  	cwd, err := os.Getwd()
    26  	require.NoError(t, err)
    27  	certPath := filepath.Join(cwd, "testdata", "cert.pem")
    28  	keyPath := filepath.Join(cwd, "testdata", "key.pem")
    29  
    30  	certBytes, err := ioutil.ReadFile(filepath.Join("testdata", "cert.pem"))
    31  	require.NoError(t, err)
    32  
    33  	keyBytes, err := ioutil.ReadFile(filepath.Join("testdata", "key.pem"))
    34  	require.NoError(t, err)
    35  
    36  	t.Run("client specific cert", func(t *testing.T) {
    37  		viper.Reset()
    38  		defer viper.Reset()
    39  
    40  		viper.Set("peer.tls.enabled", true)
    41  		viper.Set("peer.tls.clientAuthRequired", true)
    42  		viper.Set("peer.tls.clientCert.file", certPath)
    43  		viper.Set("peer.tls.clientKey.file", keyPath)
    44  
    45  		coreConfig := deliverservice.GlobalConfig()
    46  
    47  		require.True(t, coreConfig.SecOpts.UseTLS)
    48  		require.True(t, coreConfig.SecOpts.RequireClientCert)
    49  		require.Equal(t, keyBytes, coreConfig.SecOpts.Key)
    50  		require.Equal(t, certBytes, coreConfig.SecOpts.Certificate)
    51  	})
    52  
    53  	t.Run("fallback cert", func(t *testing.T) {
    54  		viper.Reset()
    55  		defer viper.Reset()
    56  
    57  		viper.Set("peer.tls.enabled", true)
    58  		viper.Set("peer.tls.clientAuthRequired", true)
    59  		viper.Set("peer.tls.cert.file", certPath)
    60  		viper.Set("peer.tls.key.file", keyPath)
    61  
    62  		coreConfig := deliverservice.GlobalConfig()
    63  
    64  		require.True(t, coreConfig.SecOpts.UseTLS)
    65  		require.True(t, coreConfig.SecOpts.RequireClientCert)
    66  		require.Equal(t, keyBytes, coreConfig.SecOpts.Key)
    67  		require.Equal(t, certBytes, coreConfig.SecOpts.Certificate)
    68  	})
    69  
    70  	t.Run("no cert", func(t *testing.T) {
    71  		viper.Reset()
    72  		defer viper.Reset()
    73  
    74  		viper.Set("peer.tls.enabled", true)
    75  		viper.Set("peer.tls.clientAuthRequired", true)
    76  
    77  		require.Panics(t, func() { deliverservice.GlobalConfig() })
    78  	})
    79  }
    80  
    81  func TestGlobalConfig(t *testing.T) {
    82  	viper.Reset()
    83  	defer viper.Reset()
    84  
    85  	viper.Set("peer.tls.enabled", true)
    86  	viper.Set("peer.deliveryclient.reConnectBackoffThreshold", "25s")
    87  	viper.Set("peer.deliveryclient.reconnectTotalTimeThreshold", "20s")
    88  	viper.Set("peer.deliveryclient.connTimeout", "10s")
    89  	viper.Set("peer.keepalive.deliveryClient.interval", "5s")
    90  	viper.Set("peer.keepalive.deliveryClient.timeout", "2s")
    91  
    92  	coreConfig := deliverservice.GlobalConfig()
    93  
    94  	expectedConfig := &deliverservice.DeliverServiceConfig{
    95  		BlockGossipEnabled:          true,
    96  		PeerTLSEnabled:              true,
    97  		ReConnectBackoffThreshold:   25 * time.Second,
    98  		ReconnectTotalTimeThreshold: 20 * time.Second,
    99  		ConnectionTimeout:           10 * time.Second,
   100  		KeepaliveOptions: comm.KeepaliveOptions{
   101  			ClientInterval:    time.Second * 5,
   102  			ClientTimeout:     time.Second * 2,
   103  			ServerInterval:    time.Hour * 2,
   104  			ServerTimeout:     time.Second * 20,
   105  			ServerMinInterval: time.Minute,
   106  		},
   107  		SecOpts: comm.SecureOptions{
   108  			UseTLS: true,
   109  		},
   110  	}
   111  
   112  	require.Equal(t, expectedConfig, coreConfig)
   113  }
   114  
   115  func TestGlobalConfigDefault(t *testing.T) {
   116  	viper.Reset()
   117  	defer viper.Reset()
   118  
   119  	coreConfig := deliverservice.GlobalConfig()
   120  
   121  	expectedConfig := &deliverservice.DeliverServiceConfig{
   122  		BlockGossipEnabled:          true,
   123  		PeerTLSEnabled:              false,
   124  		ReConnectBackoffThreshold:   deliverservice.DefaultReConnectBackoffThreshold,
   125  		ReconnectTotalTimeThreshold: deliverservice.DefaultReConnectTotalTimeThreshold,
   126  		ConnectionTimeout:           deliverservice.DefaultConnectionTimeout,
   127  		KeepaliveOptions:            comm.DefaultKeepaliveOptions,
   128  	}
   129  
   130  	require.Equal(t, expectedConfig, coreConfig)
   131  }
   132  
   133  func TestLoadOverridesMap(t *testing.T) {
   134  	defer viper.Reset()
   135  
   136  	t.Run("GreenPath", func(t *testing.T) {
   137  		config := `
   138                    peer:
   139                      deliveryclient:
   140                        addressOverrides:
   141                          - from: addressFrom1
   142                            to: addressTo1
   143                            caCertsFile: testdata/cert.pem
   144                          - from: addressFrom2
   145                            to: addressTo2
   146                            caCertsFile: testdata/cert.pem
   147                  `
   148  
   149  		viper.Reset()
   150  		viper.SetConfigType("yaml")
   151  		err := viper.ReadConfig(bytes.NewBuffer([]byte(config)))
   152  		require.NoError(t, err)
   153  		res, err := deliverservice.LoadOverridesMap()
   154  		require.NoError(t, err)
   155  		require.Len(t, res, 2)
   156  		ep1, ok := res["addressFrom1"]
   157  		require.True(t, ok)
   158  		require.Equal(t, "addressTo1", ep1.Address)
   159  		ep2, ok := res["addressFrom2"]
   160  		require.True(t, ok)
   161  		require.Equal(t, "addressTo2", ep2.Address)
   162  	})
   163  
   164  	t.Run("MissingCAFiles", func(t *testing.T) {
   165  		config := `
   166                    peer:
   167                      deliveryclient:
   168                        addressOverrides:
   169                          - from: addressFrom1
   170                            to: addressTo1
   171                            caCertsFile: missing/cert.pem
   172                          - from: addressFrom2
   173                            to: addressTo2
   174                            caCertsFile: testdata/cert.pem
   175                  `
   176  
   177  		viper.Reset()
   178  		viper.SetConfigType("yaml")
   179  		err := viper.ReadConfig(bytes.NewBuffer([]byte(config)))
   180  		require.NoError(t, err)
   181  		res, err := deliverservice.LoadOverridesMap()
   182  		require.NoError(t, err)
   183  		require.Len(t, res, 1)
   184  	})
   185  
   186  	t.Run("EmptyCAFiles", func(t *testing.T) {
   187  		config := `
   188                    peer:
   189                      deliveryclient:
   190                        addressOverrides:
   191                          - from: addressFrom1
   192                            to: addressTo1
   193                          - from: addressFrom2
   194                            to: addressTo2
   195                  `
   196  
   197  		viper.Reset()
   198  		viper.SetConfigType("yaml")
   199  		err := viper.ReadConfig(bytes.NewBuffer([]byte(config)))
   200  		require.NoError(t, err)
   201  		res, err := deliverservice.LoadOverridesMap()
   202  		require.NoError(t, err)
   203  		require.Len(t, res, 2)
   204  	})
   205  
   206  	t.Run("BadYaml", func(t *testing.T) {
   207  		config := `
   208                    peer:
   209                      deliveryclient:
   210                        addressOverrides: foo
   211                  `
   212  
   213  		viper.Reset()
   214  		viper.SetConfigType("yaml")
   215  		err := viper.ReadConfig(bytes.NewBuffer([]byte(config)))
   216  		require.NoError(t, err)
   217  		_, err = deliverservice.LoadOverridesMap()
   218  		require.Error(t, err)
   219  		require.Contains(t, err.Error(), "could not unmarshal peer.deliveryclient.addressOverrides:")
   220  	})
   221  
   222  	t.Run("EmptyYaml", func(t *testing.T) {
   223  		config := `
   224                    peer:
   225                      deliveryclient:
   226                  `
   227  
   228  		viper.Reset()
   229  		viper.SetConfigType("yaml")
   230  		err := viper.ReadConfig(bytes.NewBuffer([]byte(config)))
   231  		require.NoError(t, err)
   232  		res, err := deliverservice.LoadOverridesMap()
   233  		require.NoError(t, err)
   234  		require.Nil(t, res)
   235  	})
   236  }