diff --git a/pkg/config/model_test.go b/pkg/config/model_test.go
index ac74f891..4e05c399 100644
--- a/pkg/config/model_test.go
+++ b/pkg/config/model_test.go
@@ -18,7 +18,11 @@
 package config_test
 
 import (
+	"fmt"
+	"io"
+	"os"
 	"testing"
+	"time"
 )
 
 import (
@@ -129,3 +133,311 @@ func TestUnmarshalText(t *testing.T) {
 	assert.Nil(t, err)
 	assert.Equal(t, config.MySQL, protocolType)
 }
+
+func TestParametersMap_LowerCaseFirstLetter(t *testing.T) {
+	type args struct {
+		str string
+	}
+	tests := []struct {
+		name string
+		pm   config.ParametersMap
+		args args
+		want string
+	}{
+		{
+			name: "test lower case first letter",
+			pm:   config.ParametersMap{},
+			args: args{
+				str: "Arana",
+			},
+			want: "arana",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equalf(t, tt.want, tt.pm.LowerCaseFirstLetter(tt.args.str), "LowerCaseFirstLetter(%v)", tt.args.str)
+		})
+	}
+}
+
+func TestDecoder_Decode(t *testing.T) {
+	type fields struct {
+		reader io.Reader
+	}
+	type args struct {
+		v interface{}
+	}
+
+	f, err := os.Open(FakeConfigPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		_ = f.Close()
+	}()
+
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{
+			name: "test decode",
+			args: args{
+				v: &config.Configuration{},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := config.NewDecoder(f).Decode(tt.args.v); err != nil {
+				t.Errorf("Decode() error = %v", err)
+			}
+		})
+	}
+}
+
+func TestLoad(t *testing.T) {
+	type args struct {
+		path string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *config.Configuration
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{
+			name: "test load",
+			args: args{
+				path: FakeConfigPath,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := config.Load(tt.args.path)
+			if err != nil {
+				t.Errorf("Load() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			t.Logf("got: %+v", got)
+		})
+	}
+}
+
+func TestTenant_Empty(t1 *testing.T) {
+	type fields struct {
+		Spec               config.Spec
+		Name               string
+		Users              []*config.User
+		SysDB              *config.Node
+		DataSourceClusters []*config.DataSourceCluster
+		ShardingRule       *config.ShardingRule
+		ShadowRule         *config.ShadowRule
+		Nodes              map[string]*config.Node
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   bool
+	}{
+		{
+			name: "test empty",
+			fields: fields{
+				Spec:               config.Spec{},
+				Name:               "",
+				Users:              nil,
+				SysDB:              nil,
+				DataSourceClusters: nil,
+				ShardingRule:       nil,
+				ShadowRule:         nil,
+				Nodes:              nil,
+			},
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		t1.Run(tt.name, func(t1 *testing.T) {
+			t := &config.Tenant{
+				Spec:               tt.fields.Spec,
+				Name:               tt.fields.Name,
+				Users:              tt.fields.Users,
+				SysDB:              tt.fields.SysDB,
+				DataSourceClusters: tt.fields.DataSourceClusters,
+				ShardingRule:       tt.fields.ShardingRule,
+				ShadowRule:         tt.fields.ShadowRule,
+				Nodes:              tt.fields.Nodes,
+			}
+			assert.Equalf(t1, tt.want, t.Empty(), "Empty()")
+		})
+	}
+}
+
+func TestNode_GetReadAndWriteWeight(t *testing.T) {
+	type fields *config.Node
+
+	node := &config.Node{
+		Name:      "arana-node-1",
+		Host:      "arana-mysql",
+		Port:      3306,
+		Username:  "root",
+		Password:  "123456",
+		Database:  "employees",
+		ConnProps: nil,
+		Weight:    "r10w10",
+		Labels:    nil,
+	}
+
+	tests := []struct {
+		name    string
+		fields  fields
+		want    int
+		want1   int
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{
+			name:   "test get read and write weight",
+			fields: node,
+			want:   10,
+			want1:  10,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, got1, err := node.GetReadAndWriteWeight()
+			if err != nil {
+				t.Errorf("GetReadAndWriteWeight() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			assert.Equal(t, tt.want, got)
+			assert.Equal(t, tt.want1, got1)
+		})
+	}
+}
+
+func TestGetConnPropCapacity(t *testing.T) {
+	type args struct {
+		connProps    map[string]interface{}
+		defaultValue int
+	}
+	tests := []struct {
+		name string
+		args args
+		want int
+	}{
+		{
+			name: "test get conn prop capacity",
+			args: args{
+				connProps: map[string]interface{}{
+					"capacity": 10,
+				},
+				defaultValue: 1,
+			},
+			want: 10,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equalf(t, tt.want, config.GetConnPropCapacity(tt.args.connProps, tt.args.defaultValue), "GetConnPropCapacity(%v, %v)", tt.args.connProps, tt.args.defaultValue)
+		})
+	}
+}
+
+func TestGetConnPropMaxCapacity(t *testing.T) {
+	type args struct {
+		connProps    map[string]interface{}
+		defaultValue int
+	}
+	tests := []struct {
+		name string
+		args args
+		want int
+	}{
+		{
+			name: "test get conn prop max capacity",
+			args: args{
+				connProps: map[string]interface{}{
+					"maxCapacity": 10,
+				},
+				defaultValue: 1,
+			},
+			want: 10,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equalf(t, tt.want, config.GetConnPropMaxCapacity(tt.args.connProps, tt.args.defaultValue), "GetConnPropMaxCapacity(%v, %v)", tt.args.connProps, tt.args.defaultValue)
+		})
+	}
+}
+
+func TestGetConnPropIdleTime(t *testing.T) {
+	type args struct {
+		connProps    map[string]interface{}
+		defaultValue time.Duration
+	}
+	tests := []struct {
+		name string
+		args args
+		want time.Duration
+	}{
+		{
+			name: "test get conn prop idle time",
+			args: args{
+				connProps: map[string]interface{}{
+					"idle_time": "10s",
+				},
+				defaultValue: 1 * time.Second,
+			},
+			want: 10 * time.Second,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equalf(t, tt.want, config.GetConnPropIdleTime(tt.args.connProps, tt.args.defaultValue), "GetConnPropIdleTime(%v, %v)", tt.args.connProps, tt.args.defaultValue)
+		})
+	}
+}
+
+func TestListener_String(t *testing.T) {
+	type fields struct {
+		ProtocolType  string
+		SocketAddress *config.SocketAddress
+		ServerVersion string
+	}
+
+	socketAddr := fmt.Sprintf("%s:%d", "127.0.0.1", 3306)
+	want := fmt.Sprintf("Listener protocol_type:%s, socket_address:%s, server_version:%s", "mysql", socketAddr, "5.7.25")
+
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		{
+			name: "test listener string",
+			fields: fields{
+				ProtocolType: "mysql",
+				SocketAddress: &config.SocketAddress{
+					Address: "127.0.0.1",
+					Port:    3306,
+				},
+				ServerVersion: "5.7.25",
+			},
+			want: want,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			l := &config.Listener{
+				ProtocolType:  tt.fields.ProtocolType,
+				SocketAddress: tt.fields.SocketAddress,
+				ServerVersion: tt.fields.ServerVersion,
+			}
+			assert.Equalf(t, tt.want, l.String(), "String()")
+		})
+	}
+}