github.com/phamtai97/go-utils@v0.6.2/utils/config/config_test.go (about)

     1  package config
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/phamtai97/go-utils/utils/logger"
     7  	"github.com/stretchr/testify/assert"
     8  )
     9  
    10  type ServiceConfigYaml struct {
    11  	Bootstrap  BootstrapConfigYaml
    12  	Datasource DataSourceConfigYaml
    13  }
    14  
    15  type BootstrapConfigYaml struct {
    16  	Env            string
    17  	Token          string
    18  	Password       []string
    19  	WorkerPoolSize int  `yaml:"workerPoolSize"`
    20  	EnabledJob     bool `yaml:"enabledJob"`
    21  }
    22  
    23  type DataSourceConfigYaml struct {
    24  	AccountDS DatabaseConfigYaml `yaml:"accountDS"`
    25  	SystemDS  DatabaseConfigYaml `yaml:"systemDS"`
    26  }
    27  
    28  type DatabaseConfigYaml struct {
    29  	Host      string
    30  	Port      int
    31  	Username  string
    32  	Password  string
    33  	TableName []string `yaml:"tableName"`
    34  }
    35  
    36  type ServiceConfigJson struct {
    37  	Bootstrap  BootstrapConfigJson
    38  	Datasource DataSourceConfigJson
    39  }
    40  
    41  type BootstrapConfigJson struct {
    42  	Env            string
    43  	Token          string
    44  	Password       []string
    45  	WorkerPoolSize int  `json:"workerPoolSize"`
    46  	EnabledJob     bool `json:"enabledJob"`
    47  }
    48  
    49  type DataSourceConfigJson struct {
    50  	AccountDS DatabaseConfigJson `json:"accountDS"`
    51  	SystemDS  DatabaseConfigJson `json:"systemDS"`
    52  }
    53  
    54  type DatabaseConfigJson struct {
    55  	Host      string
    56  	Port      int
    57  	Username  string
    58  	Password  string
    59  	TableName []string `json:"tableName"`
    60  }
    61  
    62  func TestLoadYaml_SimpleInput_Success(t *testing.T) {
    63  	// GIVEN
    64  	assert := assert.New(t)
    65  	passwordArr := []string{"abc", "123"}
    66  	tableNameAccArr := []string{"Test1", "Test2", "Test3"}
    67  	tableNameSysArr := []string{"Test4", "Test5", "Test6"}
    68  
    69  	// WHEN
    70  	serviceConfig := ServiceConfigYaml{}
    71  	err := Load(&serviceConfig, "config.yaml")
    72  
    73  	// THEN
    74  	assert.Nil(err)
    75  	assert.NotNil(serviceConfig)
    76  	bootstrap := serviceConfig.Bootstrap
    77  	datasource := serviceConfig.Datasource
    78  
    79  	assert.NotNil(bootstrap)
    80  	assert.NotNil(datasource)
    81  
    82  	assert.Equal("DEV", bootstrap.Env)
    83  	assert.Equal("xyz1234567890", bootstrap.Token)
    84  	assert.Equal(passwordArr, bootstrap.Password)
    85  	assert.Equal(20, bootstrap.WorkerPoolSize)
    86  	assert.Equal(false, bootstrap.EnabledJob)
    87  
    88  	accountDS := datasource.AccountDS
    89  	systemDS := datasource.SystemDS
    90  
    91  	assert.NotNil(accountDS)
    92  	assert.NotNil(systemDS)
    93  
    94  	assert.Equal("9.9.9.9", accountDS.Host)
    95  	assert.Equal(9090, accountDS.Port)
    96  	assert.Equal("ajpham97", accountDS.Username)
    97  	assert.Equal("abc@123", accountDS.Password)
    98  	assert.Equal(tableNameAccArr, accountDS.TableName)
    99  
   100  	assert.Equal("8.8.8.8", systemDS.Host)
   101  	assert.Equal(8080, systemDS.Port)
   102  	assert.Equal("ajpham97", systemDS.Username)
   103  	assert.Equal("123@abc", systemDS.Password)
   104  	assert.Equal(tableNameSysArr, systemDS.TableName)
   105  }
   106  
   107  func TestLoadYamlByFlag_SimpleInput_Success(t *testing.T) {
   108  	// GIVEN
   109  	assert := assert.New(t)
   110  	passwordArr := []string{"abc", "123"}
   111  	tableNameAccArr := []string{"Test1", "Test2", "Test3"}
   112  	tableNameSysArr := []string{"Test4", "Test5", "Test6"}
   113  
   114  	// WHEN
   115  	serviceConfig := ServiceConfigYaml{}
   116  	err := LoadByFlag(&serviceConfig, "cfgPathYaml")
   117  
   118  	// THEN
   119  	assert.Nil(err)
   120  	assert.NotNil(serviceConfig)
   121  	bootstrap := serviceConfig.Bootstrap
   122  	datasource := serviceConfig.Datasource
   123  
   124  	assert.NotNil(bootstrap)
   125  	assert.NotNil(datasource)
   126  
   127  	assert.Equal("DEV", bootstrap.Env)
   128  	assert.Equal("xyz1234567890", bootstrap.Token)
   129  	assert.Equal(passwordArr, bootstrap.Password)
   130  	assert.Equal(20, bootstrap.WorkerPoolSize)
   131  	assert.Equal(false, bootstrap.EnabledJob)
   132  
   133  	accountDS := datasource.AccountDS
   134  	systemDS := datasource.SystemDS
   135  
   136  	assert.NotNil(accountDS)
   137  	assert.NotNil(systemDS)
   138  
   139  	assert.Equal("9.9.9.9", accountDS.Host)
   140  	assert.Equal(9090, accountDS.Port)
   141  	assert.Equal("ajpham97", accountDS.Username)
   142  	assert.Equal("abc@123", accountDS.Password)
   143  	assert.Equal(tableNameAccArr, accountDS.TableName)
   144  
   145  	assert.Equal("8.8.8.8", systemDS.Host)
   146  	assert.Equal(8080, systemDS.Port)
   147  	assert.Equal("ajpham97", systemDS.Username)
   148  	assert.Equal("123@abc", systemDS.Password)
   149  	assert.Equal(tableNameSysArr, systemDS.TableName)
   150  }
   151  
   152  func TestLoadYaml_InvalidFile_FailedToLoadConfig(t *testing.T) {
   153  	// GIVEN
   154  	assert := assert.New(t)
   155  
   156  	// WHEN
   157  	serviceConfig := ServiceConfigYaml{}
   158  	err := Load(&serviceConfig, "./config.txt")
   159  
   160  	// THEN
   161  	assert.Equal("Can not support load file ./config.txt", err.Error())
   162  }
   163  
   164  func TestLoadJson_SimpleInput_Success(t *testing.T) {
   165  	// GIVEN
   166  	assert := assert.New(t)
   167  	passwordArr := []string{"abc", "123"}
   168  	tableNameAccArr := []string{"Test1", "Test2", "Test3"}
   169  	tableNameSysArr := []string{"Test4", "Test5", "Test6"}
   170  
   171  	// WHEN
   172  	serviceConfig := ServiceConfigJson{}
   173  	err := Load(&serviceConfig, "config.json")
   174  
   175  	// THEN
   176  	assert.Nil(err)
   177  	assert.NotNil(serviceConfig)
   178  	bootstrap := serviceConfig.Bootstrap
   179  	datasource := serviceConfig.Datasource
   180  
   181  	assert.NotNil(bootstrap)
   182  	assert.NotNil(datasource)
   183  
   184  	assert.Equal("DEV", bootstrap.Env)
   185  	assert.Equal("xyz1234567890", bootstrap.Token)
   186  	assert.Equal(passwordArr, bootstrap.Password)
   187  	assert.Equal(20, bootstrap.WorkerPoolSize)
   188  	assert.Equal(false, bootstrap.EnabledJob)
   189  
   190  	accountDS := datasource.AccountDS
   191  	systemDS := datasource.SystemDS
   192  
   193  	assert.NotNil(accountDS)
   194  	assert.NotNil(systemDS)
   195  
   196  	assert.Equal("9.9.9.9", accountDS.Host)
   197  	assert.Equal(9090, accountDS.Port)
   198  	assert.Equal("ajpham97", accountDS.Username)
   199  	assert.Equal("abc@123", accountDS.Password)
   200  	assert.Equal(tableNameAccArr, accountDS.TableName)
   201  
   202  	assert.Equal("8.8.8.8", systemDS.Host)
   203  	assert.Equal(8080, systemDS.Port)
   204  	assert.Equal("ajpham97", systemDS.Username)
   205  	assert.Equal("123@abc", systemDS.Password)
   206  	assert.Equal(tableNameSysArr, systemDS.TableName)
   207  }
   208  
   209  func TestPrint_SimpleInput_Success(t *testing.T) {
   210  	// GIVEN
   211  	assert := assert.New(t)
   212  	logger.InitProduction("")
   213  
   214  	// WHEN
   215  	serviceConfig := ServiceConfigYaml{}
   216  	err := Load(&serviceConfig, "config.yaml")
   217  	errPrint := Print(serviceConfig)
   218  
   219  	// THEN
   220  	assert.Nil(err)
   221  	assert.Nil(errPrint)
   222  }
   223  func TestPrint_OmittedKeys_Success(t *testing.T) {
   224  	// GIVEN
   225  	assert := assert.New(t)
   226  	logger.InitProduction("")
   227  
   228  	// WHEN
   229  	serviceConfig := ServiceConfigYaml{}
   230  	err := Load(&serviceConfig, "config.yaml")
   231  	errPrint := Print(serviceConfig, "Token", "Password")
   232  
   233  	// THEN
   234  	assert.Nil(err)
   235  	assert.Nil(errPrint)
   236  }
   237  
   238  func TestPrint_ConfigIsNull_Success(t *testing.T) {
   239  	// GIVEN
   240  	assert := assert.New(t)
   241  	logger.InitProduction("")
   242  
   243  	// WHEN
   244  	errPrint := Print(nil, "Token", "Password")
   245  
   246  	// THEN
   247  	assert.Nil(errPrint)
   248  }
   249  
   250  func TestPrint_InvalidConfig_Success(t *testing.T) {
   251  	// GIVEN
   252  	assert := assert.New(t)
   253  	logger.InitProduction("")
   254  
   255  	// WHEN
   256  	errPrint := Print("", "Token", "Password")
   257  
   258  	// THEN
   259  	assert.Equal("json: cannot unmarshal string into Go value of type map[string]interface {}", errPrint.Error())
   260  }
   261  
   262  func BenchmarkLoadYaml(b *testing.B) {
   263  	serviceConfig := ServiceConfigYaml{}
   264  	Load(&serviceConfig, "config.yaml")
   265  }
   266  
   267  func BenchmarkLoadJson(b *testing.B) {
   268  	serviceConfig := ServiceConfigJson{}
   269  	Load(&serviceConfig, "config.json")
   270  }