diff --git a/go.mod b/go.mod
index 2ae5d98..e264f1a 100644
--- a/go.mod
+++ b/go.mod
@@ -3,6 +3,7 @@ module gitee.com/wheat-os/wheatCache
 go 1.16
 
 require (
+	github.com/golang/mock v1.5.0
 	github.com/spf13/cobra v1.2.1
 	github.com/spf13/viper v1.8.1
 	github.com/stretchr/testify v1.7.0
diff --git a/go.sum b/go.sum
index 81376ca..13b7359 100644
--- a/go.sum
+++ b/go.sum
@@ -89,6 +89,7 @@ github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt
 github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
 github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
 github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
+github.com/golang/mock v1.5.0 h1:jlYHihg//f7RRwuPfptm04yp4s7O6Kw8EZiVYIGcH0g=
 github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
diff --git a/makefile b/makefile
index 65558eb..f2ef223 100644
--- a/makefile
+++ b/makefile
@@ -52,3 +52,7 @@ init-conf:
 .PHONY: gen-service
 gen-service:
 	@python3 ./shell/make_service.py
+
+.PHONY: gen-mock
+gen-mock:
+	@mockgen -source=./pkg/proto/storage.pb.go CommServerClient > ./mock/storage/mock_client.gen.go
\ No newline at end of file
diff --git a/mock/storage/mock_client.gen.go b/mock/storage/mock_client.gen.go
new file mode 100644
index 0000000..32988a2
--- /dev/null
+++ b/mock/storage/mock_client.gen.go
@@ -0,0 +1,1600 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: ./pkg/proto/storage.pb.go
+
+// Package mock_proto is a generated GoMock package.
+package mock_proto
+
+import (
+	context "context"
+	reflect "reflect"
+
+	proto "gitee.com/wheat-os/wheatCache/pkg/proto"
+	gomock "github.com/golang/mock/gomock"
+	grpc "google.golang.org/grpc"
+)
+
+// MockCommServerClient is a mock of CommServerClient interface.
+type MockCommServerClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockCommServerClientMockRecorder
+}
+
+// MockCommServerClientMockRecorder is the mock recorder for MockCommServerClient.
+type MockCommServerClientMockRecorder struct {
+	mock *MockCommServerClient
+}
+
+// NewMockCommServerClient creates a new mock instance.
+func NewMockCommServerClient(ctrl *gomock.Controller) *MockCommServerClient {
+	mock := &MockCommServerClient{ctrl: ctrl}
+	mock.recorder = &MockCommServerClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockCommServerClient) EXPECT() *MockCommServerClientMockRecorder {
+	return m.recorder
+}
+
+// Add mocks base method.
+func (m *MockCommServerClient) Add(ctx context.Context, in *proto.AddRequest, opts ...grpc.CallOption) (*proto.AddResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Add", varargs...)
+	ret0, _ := ret[0].(*proto.AddResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Add indicates an expected call of Add.
+func (mr *MockCommServerClientMockRecorder) Add(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockCommServerClient)(nil).Add), varargs...)
+}
+
+// Get mocks base method.
+func (m *MockCommServerClient) Get(ctx context.Context, in *proto.GetRequest, opts ...grpc.CallOption) (*proto.GetResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Get", varargs...)
+	ret0, _ := ret[0].(*proto.GetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get.
+func (mr *MockCommServerClientMockRecorder) Get(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCommServerClient)(nil).Get), varargs...)
+}
+
+// GetBit mocks base method.
+func (m *MockCommServerClient) GetBit(ctx context.Context, in *proto.GetBitRequest, opts ...grpc.CallOption) (*proto.GetBitResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetBit", varargs...)
+	ret0, _ := ret[0].(*proto.GetBitResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBit indicates an expected call of GetBit.
+func (mr *MockCommServerClientMockRecorder) GetBit(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBit", reflect.TypeOf((*MockCommServerClient)(nil).GetBit), varargs...)
+}
+
+// GetRange mocks base method.
+func (m *MockCommServerClient) GetRange(ctx context.Context, in *proto.GetRangeRequest, opts ...grpc.CallOption) (*proto.GetRangeResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetRange", varargs...)
+	ret0, _ := ret[0].(*proto.GetRangeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRange indicates an expected call of GetRange.
+func (mr *MockCommServerClientMockRecorder) GetRange(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockCommServerClient)(nil).GetRange), varargs...)
+}
+
+// GetSet mocks base method.
+func (m *MockCommServerClient) GetSet(ctx context.Context, in *proto.GetSetRequest, opts ...grpc.CallOption) (*proto.GetSetResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetSet", varargs...)
+	ret0, _ := ret[0].(*proto.GetSetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSet indicates an expected call of GetSet.
+func (mr *MockCommServerClientMockRecorder) GetSet(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockCommServerClient)(nil).GetSet), varargs...)
+}
+
+// HDel mocks base method.
+func (m *MockCommServerClient) HDel(ctx context.Context, in *proto.HDelRequest, opts ...grpc.CallOption) (*proto.HDelResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "HDel", varargs...)
+	ret0, _ := ret[0].(*proto.HDelResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HDel indicates an expected call of HDel.
+func (mr *MockCommServerClientMockRecorder) HDel(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HDel", reflect.TypeOf((*MockCommServerClient)(nil).HDel), varargs...)
+}
+
+// HExists mocks base method.
+func (m *MockCommServerClient) HExists(ctx context.Context, in *proto.HExistsRequest, opts ...grpc.CallOption) (*proto.HExistsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "HExists", varargs...)
+	ret0, _ := ret[0].(*proto.HExistsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HExists indicates an expected call of HExists.
+func (mr *MockCommServerClientMockRecorder) HExists(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockCommServerClient)(nil).HExists), varargs...)
+}
+
+// HGet mocks base method.
+func (m *MockCommServerClient) HGet(ctx context.Context, in *proto.HGetRequest, opts ...grpc.CallOption) (*proto.HGetResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "HGet", varargs...)
+	ret0, _ := ret[0].(*proto.HGetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HGet indicates an expected call of HGet.
+func (mr *MockCommServerClientMockRecorder) HGet(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockCommServerClient)(nil).HGet), varargs...)
+}
+
+// HGetAll mocks base method.
+func (m *MockCommServerClient) HGetAll(ctx context.Context, in *proto.HGetAllRequest, opts ...grpc.CallOption) (*proto.HGetAllResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "HGetAll", varargs...)
+	ret0, _ := ret[0].(*proto.HGetAllResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HGetAll indicates an expected call of HGetAll.
+func (mr *MockCommServerClientMockRecorder) HGetAll(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetAll", reflect.TypeOf((*MockCommServerClient)(nil).HGetAll), varargs...)
+}
+
+// HIncrBy mocks base method.
+func (m *MockCommServerClient) HIncrBy(ctx context.Context, in *proto.HIncrByRequest, opts ...grpc.CallOption) (*proto.HIncrByResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "HIncrBy", varargs...)
+	ret0, _ := ret[0].(*proto.HIncrByResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HIncrBy indicates an expected call of HIncrBy.
+func (mr *MockCommServerClientMockRecorder) HIncrBy(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrBy", reflect.TypeOf((*MockCommServerClient)(nil).HIncrBy), varargs...)
+}
+
+// HKeys mocks base method.
+func (m *MockCommServerClient) HKeys(ctx context.Context, in *proto.HKeysRequest, opts ...grpc.CallOption) (*proto.HKeysResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "HKeys", varargs...)
+	ret0, _ := ret[0].(*proto.HKeysResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HKeys indicates an expected call of HKeys.
+func (mr *MockCommServerClientMockRecorder) HKeys(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HKeys", reflect.TypeOf((*MockCommServerClient)(nil).HKeys), varargs...)
+}
+
+// HLen mocks base method.
+func (m *MockCommServerClient) HLen(ctx context.Context, in *proto.HLenRequest, opts ...grpc.CallOption) (*proto.HLenResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "HLen", varargs...)
+	ret0, _ := ret[0].(*proto.HLenResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HLen indicates an expected call of HLen.
+func (mr *MockCommServerClientMockRecorder) HLen(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HLen", reflect.TypeOf((*MockCommServerClient)(nil).HLen), varargs...)
+}
+
+// HSet mocks base method.
+func (m *MockCommServerClient) HSet(ctx context.Context, in *proto.HSetRequest, opts ...grpc.CallOption) (*proto.HSetResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "HSet", varargs...)
+	ret0, _ := ret[0].(*proto.HSetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HSet indicates an expected call of HSet.
+func (mr *MockCommServerClientMockRecorder) HSet(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSet", reflect.TypeOf((*MockCommServerClient)(nil).HSet), varargs...)
+}
+
+// HSetX mocks base method.
+func (m *MockCommServerClient) HSetX(ctx context.Context, in *proto.HSetXRequest, opts ...grpc.CallOption) (*proto.HSetXResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "HSetX", varargs...)
+	ret0, _ := ret[0].(*proto.HSetXResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HSetX indicates an expected call of HSetX.
+func (mr *MockCommServerClientMockRecorder) HSetX(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetX", reflect.TypeOf((*MockCommServerClient)(nil).HSetX), varargs...)
+}
+
+// LIndex mocks base method.
+func (m *MockCommServerClient) LIndex(ctx context.Context, in *proto.LIndexRequest, opts ...grpc.CallOption) (*proto.LIndexResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "LIndex", varargs...)
+	ret0, _ := ret[0].(*proto.LIndexResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LIndex indicates an expected call of LIndex.
+func (mr *MockCommServerClientMockRecorder) LIndex(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockCommServerClient)(nil).LIndex), varargs...)
+}
+
+// LLen mocks base method.
+func (m *MockCommServerClient) LLen(ctx context.Context, in *proto.LLenRequest, opts ...grpc.CallOption) (*proto.LLenResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "LLen", varargs...)
+	ret0, _ := ret[0].(*proto.LLenResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LLen indicates an expected call of LLen.
+func (mr *MockCommServerClientMockRecorder) LLen(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LLen", reflect.TypeOf((*MockCommServerClient)(nil).LLen), varargs...)
+}
+
+// LPop mocks base method.
+func (m *MockCommServerClient) LPop(ctx context.Context, in *proto.LPopRequest, opts ...grpc.CallOption) (*proto.LPopResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "LPop", varargs...)
+	ret0, _ := ret[0].(*proto.LPopResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LPop indicates an expected call of LPop.
+func (mr *MockCommServerClientMockRecorder) LPop(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPop", reflect.TypeOf((*MockCommServerClient)(nil).LPop), varargs...)
+}
+
+// LPush mocks base method.
+func (m *MockCommServerClient) LPush(ctx context.Context, in *proto.LPushRequest, opts ...grpc.CallOption) (*proto.LPushResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "LPush", varargs...)
+	ret0, _ := ret[0].(*proto.LPushResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LPush indicates an expected call of LPush.
+func (mr *MockCommServerClientMockRecorder) LPush(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPush", reflect.TypeOf((*MockCommServerClient)(nil).LPush), varargs...)
+}
+
+// LPushX mocks base method.
+func (m *MockCommServerClient) LPushX(ctx context.Context, in *proto.LPushXRequest, opts ...grpc.CallOption) (*proto.LPushXResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "LPushX", varargs...)
+	ret0, _ := ret[0].(*proto.LPushXResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LPushX indicates an expected call of LPushX.
+func (mr *MockCommServerClientMockRecorder) LPushX(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPushX", reflect.TypeOf((*MockCommServerClient)(nil).LPushX), varargs...)
+}
+
+// LRange mocks base method.
+func (m *MockCommServerClient) LRange(ctx context.Context, in *proto.LRangeRequest, opts ...grpc.CallOption) (*proto.LRangeResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "LRange", varargs...)
+	ret0, _ := ret[0].(*proto.LRangeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LRange indicates an expected call of LRange.
+func (mr *MockCommServerClientMockRecorder) LRange(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRange", reflect.TypeOf((*MockCommServerClient)(nil).LRange), varargs...)
+}
+
+// LRem mocks base method.
+func (m *MockCommServerClient) LRem(ctx context.Context, in *proto.LRemRequest, opts ...grpc.CallOption) (*proto.LRemResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "LRem", varargs...)
+	ret0, _ := ret[0].(*proto.LRemResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LRem indicates an expected call of LRem.
+func (mr *MockCommServerClientMockRecorder) LRem(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockCommServerClient)(nil).LRem), varargs...)
+}
+
+// LSet mocks base method.
+func (m *MockCommServerClient) LSet(ctx context.Context, in *proto.LSetRequest, opts ...grpc.CallOption) (*proto.LSetResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "LSet", varargs...)
+	ret0, _ := ret[0].(*proto.LSetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LSet indicates an expected call of LSet.
+func (mr *MockCommServerClientMockRecorder) LSet(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockCommServerClient)(nil).LSet), varargs...)
+}
+
+// LTrim mocks base method.
+func (m *MockCommServerClient) LTrim(ctx context.Context, in *proto.LTrimRequest, opts ...grpc.CallOption) (*proto.LTrimResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "LTrim", varargs...)
+	ret0, _ := ret[0].(*proto.LTrimResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LTrim indicates an expected call of LTrim.
+func (mr *MockCommServerClientMockRecorder) LTrim(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockCommServerClient)(nil).LTrim), varargs...)
+}
+
+// RPop mocks base method.
+func (m *MockCommServerClient) RPop(ctx context.Context, in *proto.RPopRequest, opts ...grpc.CallOption) (*proto.RPopResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RPop", varargs...)
+	ret0, _ := ret[0].(*proto.RPopResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RPop indicates an expected call of RPop.
+func (mr *MockCommServerClientMockRecorder) RPop(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPop", reflect.TypeOf((*MockCommServerClient)(nil).RPop), varargs...)
+}
+
+// RPush mocks base method.
+func (m *MockCommServerClient) RPush(ctx context.Context, in *proto.RPushRequest, opts ...grpc.CallOption) (*proto.RPushResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RPush", varargs...)
+	ret0, _ := ret[0].(*proto.RPushResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RPush indicates an expected call of RPush.
+func (mr *MockCommServerClientMockRecorder) RPush(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPush", reflect.TypeOf((*MockCommServerClient)(nil).RPush), varargs...)
+}
+
+// RPushX mocks base method.
+func (m *MockCommServerClient) RPushX(ctx context.Context, in *proto.RPushXRequest, opts ...grpc.CallOption) (*proto.RPushXResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RPushX", varargs...)
+	ret0, _ := ret[0].(*proto.RPushXResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RPushX indicates an expected call of RPushX.
+func (mr *MockCommServerClientMockRecorder) RPushX(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPushX", reflect.TypeOf((*MockCommServerClient)(nil).RPushX), varargs...)
+}
+
+// Reduce mocks base method.
+func (m *MockCommServerClient) Reduce(ctx context.Context, in *proto.ReduceRequest, opts ...grpc.CallOption) (*proto.ReduceResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Reduce", varargs...)
+	ret0, _ := ret[0].(*proto.ReduceResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Reduce indicates an expected call of Reduce.
+func (mr *MockCommServerClientMockRecorder) Reduce(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reduce", reflect.TypeOf((*MockCommServerClient)(nil).Reduce), varargs...)
+}
+
+// SAdd mocks base method.
+func (m *MockCommServerClient) SAdd(ctx context.Context, in *proto.SAddRequest, opts ...grpc.CallOption) (*proto.SAddResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SAdd", varargs...)
+	ret0, _ := ret[0].(*proto.SAddResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SAdd indicates an expected call of SAdd.
+func (mr *MockCommServerClientMockRecorder) SAdd(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SAdd", reflect.TypeOf((*MockCommServerClient)(nil).SAdd), varargs...)
+}
+
+// SCard mocks base method.
+func (m *MockCommServerClient) SCard(ctx context.Context, in *proto.SCardRequest, opts ...grpc.CallOption) (*proto.SCardResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SCard", varargs...)
+	ret0, _ := ret[0].(*proto.SCardResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SCard indicates an expected call of SCard.
+func (mr *MockCommServerClientMockRecorder) SCard(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SCard", reflect.TypeOf((*MockCommServerClient)(nil).SCard), varargs...)
+}
+
+// SDiff mocks base method.
+func (m *MockCommServerClient) SDiff(ctx context.Context, in *proto.SDiffRequest, opts ...grpc.CallOption) (*proto.SDiffResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SDiff", varargs...)
+	ret0, _ := ret[0].(*proto.SDiffResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SDiff indicates an expected call of SDiff.
+func (mr *MockCommServerClientMockRecorder) SDiff(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiff", reflect.TypeOf((*MockCommServerClient)(nil).SDiff), varargs...)
+}
+
+// SDiffStore mocks base method.
+func (m *MockCommServerClient) SDiffStore(ctx context.Context, in *proto.SDiffStoreRequest, opts ...grpc.CallOption) (*proto.SDiffStoreResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SDiffStore", varargs...)
+	ret0, _ := ret[0].(*proto.SDiffStoreResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SDiffStore indicates an expected call of SDiffStore.
+func (mr *MockCommServerClientMockRecorder) SDiffStore(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiffStore", reflect.TypeOf((*MockCommServerClient)(nil).SDiffStore), varargs...)
+}
+
+// SInter mocks base method.
+func (m *MockCommServerClient) SInter(ctx context.Context, in *proto.SInterRequest, opts ...grpc.CallOption) (*proto.SInterResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SInter", varargs...)
+	ret0, _ := ret[0].(*proto.SInterResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SInter indicates an expected call of SInter.
+func (mr *MockCommServerClientMockRecorder) SInter(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInter", reflect.TypeOf((*MockCommServerClient)(nil).SInter), varargs...)
+}
+
+// SInterStore mocks base method.
+func (m *MockCommServerClient) SInterStore(ctx context.Context, in *proto.SInterStoreRequest, opts ...grpc.CallOption) (*proto.SInterStoreResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SInterStore", varargs...)
+	ret0, _ := ret[0].(*proto.SInterStoreResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SInterStore indicates an expected call of SInterStore.
+func (mr *MockCommServerClientMockRecorder) SInterStore(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterStore", reflect.TypeOf((*MockCommServerClient)(nil).SInterStore), varargs...)
+}
+
+// SIsMember mocks base method.
+func (m *MockCommServerClient) SIsMember(ctx context.Context, in *proto.SIsMemberRequest, opts ...grpc.CallOption) (*proto.SIsMemberResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SIsMember", varargs...)
+	ret0, _ := ret[0].(*proto.SIsMemberResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SIsMember indicates an expected call of SIsMember.
+func (mr *MockCommServerClientMockRecorder) SIsMember(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockCommServerClient)(nil).SIsMember), varargs...)
+}
+
+// SMove mocks base method.
+func (m *MockCommServerClient) SMove(ctx context.Context, in *proto.SMoveRequest, opts ...grpc.CallOption) (*proto.SMoveResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SMove", varargs...)
+	ret0, _ := ret[0].(*proto.SMoveResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SMove indicates an expected call of SMove.
+func (mr *MockCommServerClientMockRecorder) SMove(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMove", reflect.TypeOf((*MockCommServerClient)(nil).SMove), varargs...)
+}
+
+// SPop mocks base method.
+func (m *MockCommServerClient) SPop(ctx context.Context, in *proto.SPopRequest, opts ...grpc.CallOption) (*proto.SPopResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SPop", varargs...)
+	ret0, _ := ret[0].(*proto.SPopResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SPop indicates an expected call of SPop.
+func (mr *MockCommServerClientMockRecorder) SPop(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPop", reflect.TypeOf((*MockCommServerClient)(nil).SPop), varargs...)
+}
+
+// SRem mocks base method.
+func (m *MockCommServerClient) SRem(ctx context.Context, in *proto.SRemRequest, opts ...grpc.CallOption) (*proto.SRemResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SRem", varargs...)
+	ret0, _ := ret[0].(*proto.SRemResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SRem indicates an expected call of SRem.
+func (mr *MockCommServerClientMockRecorder) SRem(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRem", reflect.TypeOf((*MockCommServerClient)(nil).SRem), varargs...)
+}
+
+// SScan mocks base method.
+func (m *MockCommServerClient) SScan(ctx context.Context, in *proto.SScanRequest, opts ...grpc.CallOption) (*proto.SScanResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SScan", varargs...)
+	ret0, _ := ret[0].(*proto.SScanResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SScan indicates an expected call of SScan.
+func (mr *MockCommServerClientMockRecorder) SScan(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SScan", reflect.TypeOf((*MockCommServerClient)(nil).SScan), varargs...)
+}
+
+// SUnion mocks base method.
+func (m *MockCommServerClient) SUnion(ctx context.Context, in *proto.SUnionRequest, opts ...grpc.CallOption) (*proto.SUnionResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SUnion", varargs...)
+	ret0, _ := ret[0].(*proto.SUnionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SUnion indicates an expected call of SUnion.
+func (mr *MockCommServerClientMockRecorder) SUnion(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnion", reflect.TypeOf((*MockCommServerClient)(nil).SUnion), varargs...)
+}
+
+// SUnionStore mocks base method.
+func (m *MockCommServerClient) SUnionStore(ctx context.Context, in *proto.SUnionStoreRequest, opts ...grpc.CallOption) (*proto.SUnionStoreResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SUnionStore", varargs...)
+	ret0, _ := ret[0].(*proto.SUnionStoreResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SUnionStore indicates an expected call of SUnionStore.
+func (mr *MockCommServerClientMockRecorder) SUnionStore(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnionStore", reflect.TypeOf((*MockCommServerClient)(nil).SUnionStore), varargs...)
+}
+
+// Set mocks base method.
+func (m *MockCommServerClient) Set(ctx context.Context, in *proto.SetRequest, opts ...grpc.CallOption) (*proto.SetResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Set", varargs...)
+	ret0, _ := ret[0].(*proto.SetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Set indicates an expected call of Set.
+func (mr *MockCommServerClientMockRecorder) Set(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCommServerClient)(nil).Set), varargs...)
+}
+
+// SetBit mocks base method.
+func (m *MockCommServerClient) SetBit(ctx context.Context, in *proto.SetBitRequest, opts ...grpc.CallOption) (*proto.SetBitResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SetBit", varargs...)
+	ret0, _ := ret[0].(*proto.SetBitResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetBit indicates an expected call of SetBit.
+func (mr *MockCommServerClientMockRecorder) SetBit(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBit", reflect.TypeOf((*MockCommServerClient)(nil).SetBit), varargs...)
+}
+
+// Setnx mocks base method.
+func (m *MockCommServerClient) Setnx(ctx context.Context, in *proto.SetnxRequest, opts ...grpc.CallOption) (*proto.SetnxResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Setnx", varargs...)
+	ret0, _ := ret[0].(*proto.SetnxResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Setnx indicates an expected call of Setnx.
+func (mr *MockCommServerClientMockRecorder) Setnx(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Setnx", reflect.TypeOf((*MockCommServerClient)(nil).Setnx), varargs...)
+}
+
+// StrLen mocks base method.
+func (m *MockCommServerClient) StrLen(ctx context.Context, in *proto.StrLenRequest, opts ...grpc.CallOption) (*proto.StrLenResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "StrLen", varargs...)
+	ret0, _ := ret[0].(*proto.StrLenResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StrLen indicates an expected call of StrLen.
+func (mr *MockCommServerClientMockRecorder) StrLen(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrLen", reflect.TypeOf((*MockCommServerClient)(nil).StrLen), varargs...)
+}
+
+// MockCommServerServer is a mock of CommServerServer interface.
+type MockCommServerServer struct {
+	ctrl     *gomock.Controller
+	recorder *MockCommServerServerMockRecorder
+}
+
+// MockCommServerServerMockRecorder is the mock recorder for MockCommServerServer.
+type MockCommServerServerMockRecorder struct {
+	mock *MockCommServerServer
+}
+
+// NewMockCommServerServer creates a new mock instance.
+func NewMockCommServerServer(ctrl *gomock.Controller) *MockCommServerServer {
+	mock := &MockCommServerServer{ctrl: ctrl}
+	mock.recorder = &MockCommServerServerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockCommServerServer) EXPECT() *MockCommServerServerMockRecorder {
+	return m.recorder
+}
+
+// Add mocks base method.
+func (m *MockCommServerServer) Add(arg0 context.Context, arg1 *proto.AddRequest) (*proto.AddResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Add", arg0, arg1)
+	ret0, _ := ret[0].(*proto.AddResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Add indicates an expected call of Add.
+func (mr *MockCommServerServerMockRecorder) Add(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockCommServerServer)(nil).Add), arg0, arg1)
+}
+
+// Get mocks base method.
+func (m *MockCommServerServer) Get(arg0 context.Context, arg1 *proto.GetRequest) (*proto.GetResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Get", arg0, arg1)
+	ret0, _ := ret[0].(*proto.GetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get.
+func (mr *MockCommServerServerMockRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCommServerServer)(nil).Get), arg0, arg1)
+}
+
+// GetBit mocks base method.
+func (m *MockCommServerServer) GetBit(arg0 context.Context, arg1 *proto.GetBitRequest) (*proto.GetBitResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBit", arg0, arg1)
+	ret0, _ := ret[0].(*proto.GetBitResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBit indicates an expected call of GetBit.
+func (mr *MockCommServerServerMockRecorder) GetBit(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBit", reflect.TypeOf((*MockCommServerServer)(nil).GetBit), arg0, arg1)
+}
+
+// GetRange mocks base method.
+func (m *MockCommServerServer) GetRange(arg0 context.Context, arg1 *proto.GetRangeRequest) (*proto.GetRangeResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRange", arg0, arg1)
+	ret0, _ := ret[0].(*proto.GetRangeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRange indicates an expected call of GetRange.
+func (mr *MockCommServerServerMockRecorder) GetRange(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockCommServerServer)(nil).GetRange), arg0, arg1)
+}
+
+// GetSet mocks base method.
+func (m *MockCommServerServer) GetSet(arg0 context.Context, arg1 *proto.GetSetRequest) (*proto.GetSetResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSet", arg0, arg1)
+	ret0, _ := ret[0].(*proto.GetSetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSet indicates an expected call of GetSet.
+func (mr *MockCommServerServerMockRecorder) GetSet(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockCommServerServer)(nil).GetSet), arg0, arg1)
+}
+
+// HDel mocks base method.
+func (m *MockCommServerServer) HDel(arg0 context.Context, arg1 *proto.HDelRequest) (*proto.HDelResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HDel", arg0, arg1)
+	ret0, _ := ret[0].(*proto.HDelResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HDel indicates an expected call of HDel.
+func (mr *MockCommServerServerMockRecorder) HDel(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HDel", reflect.TypeOf((*MockCommServerServer)(nil).HDel), arg0, arg1)
+}
+
+// HExists mocks base method.
+func (m *MockCommServerServer) HExists(arg0 context.Context, arg1 *proto.HExistsRequest) (*proto.HExistsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HExists", arg0, arg1)
+	ret0, _ := ret[0].(*proto.HExistsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HExists indicates an expected call of HExists.
+func (mr *MockCommServerServerMockRecorder) HExists(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockCommServerServer)(nil).HExists), arg0, arg1)
+}
+
+// HGet mocks base method.
+func (m *MockCommServerServer) HGet(arg0 context.Context, arg1 *proto.HGetRequest) (*proto.HGetResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HGet", arg0, arg1)
+	ret0, _ := ret[0].(*proto.HGetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HGet indicates an expected call of HGet.
+func (mr *MockCommServerServerMockRecorder) HGet(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockCommServerServer)(nil).HGet), arg0, arg1)
+}
+
+// HGetAll mocks base method.
+func (m *MockCommServerServer) HGetAll(arg0 context.Context, arg1 *proto.HGetAllRequest) (*proto.HGetAllResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HGetAll", arg0, arg1)
+	ret0, _ := ret[0].(*proto.HGetAllResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HGetAll indicates an expected call of HGetAll.
+func (mr *MockCommServerServerMockRecorder) HGetAll(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetAll", reflect.TypeOf((*MockCommServerServer)(nil).HGetAll), arg0, arg1)
+}
+
+// HIncrBy mocks base method.
+func (m *MockCommServerServer) HIncrBy(arg0 context.Context, arg1 *proto.HIncrByRequest) (*proto.HIncrByResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HIncrBy", arg0, arg1)
+	ret0, _ := ret[0].(*proto.HIncrByResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HIncrBy indicates an expected call of HIncrBy.
+func (mr *MockCommServerServerMockRecorder) HIncrBy(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrBy", reflect.TypeOf((*MockCommServerServer)(nil).HIncrBy), arg0, arg1)
+}
+
+// HKeys mocks base method.
+func (m *MockCommServerServer) HKeys(arg0 context.Context, arg1 *proto.HKeysRequest) (*proto.HKeysResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HKeys", arg0, arg1)
+	ret0, _ := ret[0].(*proto.HKeysResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HKeys indicates an expected call of HKeys.
+func (mr *MockCommServerServerMockRecorder) HKeys(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HKeys", reflect.TypeOf((*MockCommServerServer)(nil).HKeys), arg0, arg1)
+}
+
+// HLen mocks base method.
+func (m *MockCommServerServer) HLen(arg0 context.Context, arg1 *proto.HLenRequest) (*proto.HLenResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HLen", arg0, arg1)
+	ret0, _ := ret[0].(*proto.HLenResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HLen indicates an expected call of HLen.
+func (mr *MockCommServerServerMockRecorder) HLen(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HLen", reflect.TypeOf((*MockCommServerServer)(nil).HLen), arg0, arg1)
+}
+
+// HSet mocks base method.
+func (m *MockCommServerServer) HSet(arg0 context.Context, arg1 *proto.HSetRequest) (*proto.HSetResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HSet", arg0, arg1)
+	ret0, _ := ret[0].(*proto.HSetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HSet indicates an expected call of HSet.
+func (mr *MockCommServerServerMockRecorder) HSet(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSet", reflect.TypeOf((*MockCommServerServer)(nil).HSet), arg0, arg1)
+}
+
+// HSetX mocks base method.
+func (m *MockCommServerServer) HSetX(arg0 context.Context, arg1 *proto.HSetXRequest) (*proto.HSetXResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HSetX", arg0, arg1)
+	ret0, _ := ret[0].(*proto.HSetXResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HSetX indicates an expected call of HSetX.
+func (mr *MockCommServerServerMockRecorder) HSetX(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetX", reflect.TypeOf((*MockCommServerServer)(nil).HSetX), arg0, arg1)
+}
+
+// LIndex mocks base method.
+func (m *MockCommServerServer) LIndex(arg0 context.Context, arg1 *proto.LIndexRequest) (*proto.LIndexResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "LIndex", arg0, arg1)
+	ret0, _ := ret[0].(*proto.LIndexResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LIndex indicates an expected call of LIndex.
+func (mr *MockCommServerServerMockRecorder) LIndex(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockCommServerServer)(nil).LIndex), arg0, arg1)
+}
+
+// LLen mocks base method.
+func (m *MockCommServerServer) LLen(arg0 context.Context, arg1 *proto.LLenRequest) (*proto.LLenResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "LLen", arg0, arg1)
+	ret0, _ := ret[0].(*proto.LLenResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LLen indicates an expected call of LLen.
+func (mr *MockCommServerServerMockRecorder) LLen(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LLen", reflect.TypeOf((*MockCommServerServer)(nil).LLen), arg0, arg1)
+}
+
+// LPop mocks base method.
+func (m *MockCommServerServer) LPop(arg0 context.Context, arg1 *proto.LPopRequest) (*proto.LPopResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "LPop", arg0, arg1)
+	ret0, _ := ret[0].(*proto.LPopResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LPop indicates an expected call of LPop.
+func (mr *MockCommServerServerMockRecorder) LPop(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPop", reflect.TypeOf((*MockCommServerServer)(nil).LPop), arg0, arg1)
+}
+
+// LPush mocks base method.
+func (m *MockCommServerServer) LPush(arg0 context.Context, arg1 *proto.LPushRequest) (*proto.LPushResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "LPush", arg0, arg1)
+	ret0, _ := ret[0].(*proto.LPushResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LPush indicates an expected call of LPush.
+func (mr *MockCommServerServerMockRecorder) LPush(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPush", reflect.TypeOf((*MockCommServerServer)(nil).LPush), arg0, arg1)
+}
+
+// LPushX mocks base method.
+func (m *MockCommServerServer) LPushX(arg0 context.Context, arg1 *proto.LPushXRequest) (*proto.LPushXResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "LPushX", arg0, arg1)
+	ret0, _ := ret[0].(*proto.LPushXResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LPushX indicates an expected call of LPushX.
+func (mr *MockCommServerServerMockRecorder) LPushX(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPushX", reflect.TypeOf((*MockCommServerServer)(nil).LPushX), arg0, arg1)
+}
+
+// LRange mocks base method.
+func (m *MockCommServerServer) LRange(arg0 context.Context, arg1 *proto.LRangeRequest) (*proto.LRangeResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "LRange", arg0, arg1)
+	ret0, _ := ret[0].(*proto.LRangeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LRange indicates an expected call of LRange.
+func (mr *MockCommServerServerMockRecorder) LRange(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRange", reflect.TypeOf((*MockCommServerServer)(nil).LRange), arg0, arg1)
+}
+
+// LRem mocks base method.
+func (m *MockCommServerServer) LRem(arg0 context.Context, arg1 *proto.LRemRequest) (*proto.LRemResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "LRem", arg0, arg1)
+	ret0, _ := ret[0].(*proto.LRemResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LRem indicates an expected call of LRem.
+func (mr *MockCommServerServerMockRecorder) LRem(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockCommServerServer)(nil).LRem), arg0, arg1)
+}
+
+// LSet mocks base method.
+func (m *MockCommServerServer) LSet(arg0 context.Context, arg1 *proto.LSetRequest) (*proto.LSetResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "LSet", arg0, arg1)
+	ret0, _ := ret[0].(*proto.LSetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LSet indicates an expected call of LSet.
+func (mr *MockCommServerServerMockRecorder) LSet(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockCommServerServer)(nil).LSet), arg0, arg1)
+}
+
+// LTrim mocks base method.
+func (m *MockCommServerServer) LTrim(arg0 context.Context, arg1 *proto.LTrimRequest) (*proto.LTrimResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "LTrim", arg0, arg1)
+	ret0, _ := ret[0].(*proto.LTrimResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LTrim indicates an expected call of LTrim.
+func (mr *MockCommServerServerMockRecorder) LTrim(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockCommServerServer)(nil).LTrim), arg0, arg1)
+}
+
+// RPop mocks base method.
+func (m *MockCommServerServer) RPop(arg0 context.Context, arg1 *proto.RPopRequest) (*proto.RPopResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RPop", arg0, arg1)
+	ret0, _ := ret[0].(*proto.RPopResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RPop indicates an expected call of RPop.
+func (mr *MockCommServerServerMockRecorder) RPop(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPop", reflect.TypeOf((*MockCommServerServer)(nil).RPop), arg0, arg1)
+}
+
+// RPush mocks base method.
+func (m *MockCommServerServer) RPush(arg0 context.Context, arg1 *proto.RPushRequest) (*proto.RPushResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RPush", arg0, arg1)
+	ret0, _ := ret[0].(*proto.RPushResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RPush indicates an expected call of RPush.
+func (mr *MockCommServerServerMockRecorder) RPush(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPush", reflect.TypeOf((*MockCommServerServer)(nil).RPush), arg0, arg1)
+}
+
+// RPushX mocks base method.
+func (m *MockCommServerServer) RPushX(arg0 context.Context, arg1 *proto.RPushXRequest) (*proto.RPushXResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RPushX", arg0, arg1)
+	ret0, _ := ret[0].(*proto.RPushXResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RPushX indicates an expected call of RPushX.
+func (mr *MockCommServerServerMockRecorder) RPushX(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPushX", reflect.TypeOf((*MockCommServerServer)(nil).RPushX), arg0, arg1)
+}
+
+// Reduce mocks base method.
+func (m *MockCommServerServer) Reduce(arg0 context.Context, arg1 *proto.ReduceRequest) (*proto.ReduceResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Reduce", arg0, arg1)
+	ret0, _ := ret[0].(*proto.ReduceResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Reduce indicates an expected call of Reduce.
+func (mr *MockCommServerServerMockRecorder) Reduce(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reduce", reflect.TypeOf((*MockCommServerServer)(nil).Reduce), arg0, arg1)
+}
+
+// SAdd mocks base method.
+func (m *MockCommServerServer) SAdd(arg0 context.Context, arg1 *proto.SAddRequest) (*proto.SAddResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SAdd", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SAddResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SAdd indicates an expected call of SAdd.
+func (mr *MockCommServerServerMockRecorder) SAdd(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SAdd", reflect.TypeOf((*MockCommServerServer)(nil).SAdd), arg0, arg1)
+}
+
+// SCard mocks base method.
+func (m *MockCommServerServer) SCard(arg0 context.Context, arg1 *proto.SCardRequest) (*proto.SCardResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SCard", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SCardResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SCard indicates an expected call of SCard.
+func (mr *MockCommServerServerMockRecorder) SCard(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SCard", reflect.TypeOf((*MockCommServerServer)(nil).SCard), arg0, arg1)
+}
+
+// SDiff mocks base method.
+func (m *MockCommServerServer) SDiff(arg0 context.Context, arg1 *proto.SDiffRequest) (*proto.SDiffResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SDiff", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SDiffResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SDiff indicates an expected call of SDiff.
+func (mr *MockCommServerServerMockRecorder) SDiff(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiff", reflect.TypeOf((*MockCommServerServer)(nil).SDiff), arg0, arg1)
+}
+
+// SDiffStore mocks base method.
+func (m *MockCommServerServer) SDiffStore(arg0 context.Context, arg1 *proto.SDiffStoreRequest) (*proto.SDiffStoreResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SDiffStore", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SDiffStoreResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SDiffStore indicates an expected call of SDiffStore.
+func (mr *MockCommServerServerMockRecorder) SDiffStore(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiffStore", reflect.TypeOf((*MockCommServerServer)(nil).SDiffStore), arg0, arg1)
+}
+
+// SInter mocks base method.
+func (m *MockCommServerServer) SInter(arg0 context.Context, arg1 *proto.SInterRequest) (*proto.SInterResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SInter", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SInterResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SInter indicates an expected call of SInter.
+func (mr *MockCommServerServerMockRecorder) SInter(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInter", reflect.TypeOf((*MockCommServerServer)(nil).SInter), arg0, arg1)
+}
+
+// SInterStore mocks base method.
+func (m *MockCommServerServer) SInterStore(arg0 context.Context, arg1 *proto.SInterStoreRequest) (*proto.SInterStoreResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SInterStore", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SInterStoreResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SInterStore indicates an expected call of SInterStore.
+func (mr *MockCommServerServerMockRecorder) SInterStore(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterStore", reflect.TypeOf((*MockCommServerServer)(nil).SInterStore), arg0, arg1)
+}
+
+// SIsMember mocks base method.
+func (m *MockCommServerServer) SIsMember(arg0 context.Context, arg1 *proto.SIsMemberRequest) (*proto.SIsMemberResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SIsMember", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SIsMemberResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SIsMember indicates an expected call of SIsMember.
+func (mr *MockCommServerServerMockRecorder) SIsMember(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockCommServerServer)(nil).SIsMember), arg0, arg1)
+}
+
+// SMove mocks base method.
+func (m *MockCommServerServer) SMove(arg0 context.Context, arg1 *proto.SMoveRequest) (*proto.SMoveResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SMove", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SMoveResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SMove indicates an expected call of SMove.
+func (mr *MockCommServerServerMockRecorder) SMove(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMove", reflect.TypeOf((*MockCommServerServer)(nil).SMove), arg0, arg1)
+}
+
+// SPop mocks base method.
+func (m *MockCommServerServer) SPop(arg0 context.Context, arg1 *proto.SPopRequest) (*proto.SPopResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SPop", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SPopResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SPop indicates an expected call of SPop.
+func (mr *MockCommServerServerMockRecorder) SPop(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPop", reflect.TypeOf((*MockCommServerServer)(nil).SPop), arg0, arg1)
+}
+
+// SRem mocks base method.
+func (m *MockCommServerServer) SRem(arg0 context.Context, arg1 *proto.SRemRequest) (*proto.SRemResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SRem", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SRemResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SRem indicates an expected call of SRem.
+func (mr *MockCommServerServerMockRecorder) SRem(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRem", reflect.TypeOf((*MockCommServerServer)(nil).SRem), arg0, arg1)
+}
+
+// SScan mocks base method.
+func (m *MockCommServerServer) SScan(arg0 context.Context, arg1 *proto.SScanRequest) (*proto.SScanResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SScan", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SScanResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SScan indicates an expected call of SScan.
+func (mr *MockCommServerServerMockRecorder) SScan(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SScan", reflect.TypeOf((*MockCommServerServer)(nil).SScan), arg0, arg1)
+}
+
+// SUnion mocks base method.
+func (m *MockCommServerServer) SUnion(arg0 context.Context, arg1 *proto.SUnionRequest) (*proto.SUnionResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SUnion", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SUnionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SUnion indicates an expected call of SUnion.
+func (mr *MockCommServerServerMockRecorder) SUnion(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnion", reflect.TypeOf((*MockCommServerServer)(nil).SUnion), arg0, arg1)
+}
+
+// SUnionStore mocks base method.
+func (m *MockCommServerServer) SUnionStore(arg0 context.Context, arg1 *proto.SUnionStoreRequest) (*proto.SUnionStoreResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SUnionStore", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SUnionStoreResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SUnionStore indicates an expected call of SUnionStore.
+func (mr *MockCommServerServerMockRecorder) SUnionStore(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnionStore", reflect.TypeOf((*MockCommServerServer)(nil).SUnionStore), arg0, arg1)
+}
+
+// Set mocks base method.
+func (m *MockCommServerServer) Set(arg0 context.Context, arg1 *proto.SetRequest) (*proto.SetResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Set", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Set indicates an expected call of Set.
+func (mr *MockCommServerServerMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCommServerServer)(nil).Set), arg0, arg1)
+}
+
+// SetBit mocks base method.
+func (m *MockCommServerServer) SetBit(arg0 context.Context, arg1 *proto.SetBitRequest) (*proto.SetBitResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetBit", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SetBitResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetBit indicates an expected call of SetBit.
+func (mr *MockCommServerServerMockRecorder) SetBit(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBit", reflect.TypeOf((*MockCommServerServer)(nil).SetBit), arg0, arg1)
+}
+
+// Setnx mocks base method.
+func (m *MockCommServerServer) Setnx(arg0 context.Context, arg1 *proto.SetnxRequest) (*proto.SetnxResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Setnx", arg0, arg1)
+	ret0, _ := ret[0].(*proto.SetnxResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Setnx indicates an expected call of Setnx.
+func (mr *MockCommServerServerMockRecorder) Setnx(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Setnx", reflect.TypeOf((*MockCommServerServer)(nil).Setnx), arg0, arg1)
+}
+
+// StrLen mocks base method.
+func (m *MockCommServerServer) StrLen(arg0 context.Context, arg1 *proto.StrLenRequest) (*proto.StrLenResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StrLen", arg0, arg1)
+	ret0, _ := ret[0].(*proto.StrLenResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StrLen indicates an expected call of StrLen.
+func (mr *MockCommServerServerMockRecorder) StrLen(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrLen", reflect.TypeOf((*MockCommServerServer)(nil).StrLen), arg0, arg1)
+}
diff --git a/storage/dao/dao_test.go b/storage/dao/dao_test.go
deleted file mode 100644
index 1909f2d..0000000
--- a/storage/dao/dao_test.go
+++ /dev/null
@@ -1,5 +0,0 @@
-package dao
-
-import (
-	_ "gitee.com/wheat-os/wheatCache/conf"
-)
diff --git a/storage/dao/stringx_test.go b/storage/dao/stringx_test.go
new file mode 100644
index 0000000..5e53c21
--- /dev/null
+++ b/storage/dao/stringx_test.go
@@ -0,0 +1,82 @@
+package dao
+
+import (
+	"testing"
+
+	"gitee.com/wheat-os/wheatCache/pkg/lru"
+	"gitee.com/wheat-os/wheatCache/pkg/proto"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDao_Set_Get(t *testing.T) {
+	baseKey := proto.NewBaseKey("abbs")
+	lru := lru.NewLRUCache()
+	dao := NewDao(lru)
+
+	_, err := dao.Set(baseKey, "bbq")
+	require.NoError(t, err)
+	resp, err := dao.Get(baseKey)
+	require.NoError(t, err)
+	require.Equal(t, resp.Result, "bbq")
+}
+
+func TestDao_Add(t *testing.T) {
+	baseKey := proto.NewBaseKey("test")
+	lru := lru.NewLRUCache()
+	dao := NewDao(lru)
+
+	// 整数 add
+	dao.Set(baseKey, "1")
+	dao.Add(baseKey, 2)
+	resp, err := dao.Get(baseKey)
+	require.NoError(t, err)
+
+	require.Equal(t, resp.Result, "3")
+
+	// 浮点数
+	dao.Set(baseKey, "1.1")
+	dao.Add(baseKey, 2)
+	resp, err = dao.Get(baseKey)
+	require.NoError(t, err)
+
+	require.Equal(t, resp.Result, "3.10")
+
+	// 字符串
+	dao.Set(baseKey, "1awd.1")
+	_, err = dao.Add(baseKey, 2)
+	require.Error(t, err)
+}
+
+func TestDao_Reduce(t *testing.T) {
+	baseKey := proto.NewBaseKey("test")
+	lru := lru.NewLRUCache()
+	dao := NewDao(lru)
+
+	// 整数 add
+	dao.Set(baseKey, "1")
+	dao.Reduce(baseKey, 2)
+	resp, err := dao.Get(baseKey)
+	require.NoError(t, err)
+
+	require.Equal(t, resp.Result, "-1")
+
+	// 浮点数
+	dao.Set(baseKey, "1.1")
+	dao.Reduce(baseKey, 2)
+	resp, err = dao.Get(baseKey)
+	require.NoError(t, err)
+
+	require.Equal(t, resp.Result, "-0.90")
+
+	// 字符串
+	dao.Set(baseKey, "1awd.1")
+	_, err = dao.Reduce(baseKey, 2)
+	require.Error(t, err)
+}
+
+// func TestDao_SetBit_GetBit(t *testing.T) {
+// 	baseKey := proto.NewBaseKey("test")
+// 	lru := lru.NewLRUCache()
+// 	dao := NewDao(lru)
+
+// }
diff --git a/storage/external/define.go b/storage/external/define.go
index af328de..69e2590 100644
--- a/storage/external/define.go
+++ b/storage/external/define.go
@@ -4,9 +4,14 @@ import (
 	"sync"
 
 	"gitee.com/wheat-os/wheatCache/pkg/proto"
+	"github.com/golang/mock/gomock"
 )
 
 var (
 	oneGatewayClient sync.Once
 	gatewayClient    proto.CommServerClient
 )
+
+var (
+	GateWayCtrl *gomock.Controller
+)
diff --git a/storage/external/gateway.go b/storage/external/gateway.go
index 3b8fe63..40c09d3 100644
--- a/storage/external/gateway.go
+++ b/storage/external/gateway.go
@@ -5,10 +5,22 @@ import (
 
 	"gitee.com/wheat-os/wheatCache/client"
 	"gitee.com/wheat-os/wheatCache/client/middle"
+	_ "gitee.com/wheat-os/wheatCache/conf"
+	mockClient "gitee.com/wheat-os/wheatCache/mock/storage"
+	"gitee.com/wheat-os/wheatCache/pkg/errorx"
 	"gitee.com/wheat-os/wheatCache/pkg/proto"
+	"github.com/spf13/viper"
 )
 
 func NewGatewayClient() (proto.CommServerClient, error) {
+
+	if viper.GetString("env") == "dev" {
+		if GateWayCtrl == nil {
+			return nil, errorx.New("mock ctrl not init")
+		}
+		return mockClient.NewMockCommServerClient(GateWayCtrl), nil
+	}
+
 	oneGatewayClient.Do(func() {
 		cli, err := client.NewWheatClient("127.0.0.1:5891", middle.WithUnaryColonyClient)
 		if err == nil {
diff --git a/storage/external/gateway_test.go b/storage/external/gateway_test.go
new file mode 100644
index 0000000..f495e77
--- /dev/null
+++ b/storage/external/gateway_test.go
@@ -0,0 +1,36 @@
+package external
+
+import (
+	"context"
+	"testing"
+
+	_ "gitee.com/wheat-os/wheatCache/conf"
+	mockClient "gitee.com/wheat-os/wheatCache/mock/storage"
+	"gitee.com/wheat-os/wheatCache/pkg/proto"
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewGatewayClient(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	GateWayCtrl = ctrl
+
+	cli, err := NewGatewayClient()
+	require.NoError(t, err)
+	mockClient := cli.(*mockClient.MockCommServerClient)
+	ctx := context.Background()
+
+	mockClient.EXPECT().Get(ctx, gomock.Any()).Return(&proto.GetResponse{
+		Result: "mockData",
+	}, nil)
+
+	resp, err := mockClient.Get(ctx, nil)
+	require.NoError(t, err)
+	require.Equal(t, resp.Result, "mockData")
+
+	resp, err = mockClient.Get(ctx, nil)
+	require.NoError(t, err)
+	require.Equal(t, resp.Result, "mockData")
+
+}