github.com/cloudwego/kitex@v0.9.0/pkg/remote/trans/gonet/mocks_test.go

/*
 * Copyright 2022 CloudWeGo Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package gonet

import (
	"context"
	"net"
	"time"

	"github.com/cloudwego/netpoll"

	"github.com/cloudwego/kitex/internal/mocks"
	"github.com/cloudwego/kitex/pkg/remote"
)

type MockCodec struct {
	EncodeFunc func(ctx context.Context, msg remote.Message, out remote.ByteBuffer) error
	DecodeFunc func(ctx context.Context, msg remote.Message, in remote.ByteBuffer) error
}

func (m *MockCodec) Name() string {
	return "Mock"
}

func (m *MockCodec) Encode(ctx context.Context, msg remote.Message, out remote.ByteBuffer) (err error) {
	if m.EncodeFunc != nil {
		return m.EncodeFunc(ctx, msg, out)
	}
	return
}

func (m *MockCodec) Decode(ctx context.Context, msg remote.Message, in remote.ByteBuffer) (err error) {
	if m.DecodeFunc != nil {
		return m.DecodeFunc(ctx, msg, in)
	}
	return
}

var _ net.Conn = &MockNetConn{}

// MockNetConn implements net.Conn.
type MockNetConn struct {
	mocks.Conn
	IsActiveFunc       func() (r bool)
	ReaderFunc         func() (r netpoll.Reader)
	WriterFunc         func() (r netpoll.Writer)
	SetIdleTimeoutFunc func(timeout time.Duration) (e error)
	SetOnRequestFunc   func(on netpoll.OnRequest) (e error)
	SetReadTimeoutFunc func(timeout time.Duration) (e error)
}

// IsActive implements the netpoll.Connection interface.
func (m *MockNetConn) IsActive() (r bool) {
	if m.IsActiveFunc != nil {
		return m.IsActiveFunc()
	}
	return
}

// Reader implements the netpoll.Connection interface.
func (m *MockNetConn) Reader() (r netpoll.Reader) {
	if m.ReaderFunc != nil {
		return m.ReaderFunc()
	}
	return
}

// Writer implements the netpoll.Connection interface.
func (m *MockNetConn) Writer() (r netpoll.Writer) {
	if m.WriterFunc != nil {
		return m.WriterFunc()
	}
	return
}

// SetIdleTimeout implements the netpoll.Connection interface.
func (m *MockNetConn) SetIdleTimeout(timeout time.Duration) (e error) {
	if m.SetIdleTimeoutFunc != nil {
		return m.SetIdleTimeoutFunc(timeout)
	}
	return
}

// SetOnRequest implements the netpoll.Connection interface.
func (m *MockNetConn) SetOnRequest(on netpoll.OnRequest) (e error) {
	if m.SetOnRequestFunc != nil {
		return m.SetOnRequestFunc(on)
	}
	return
}

// SetReadTimeout implements the netpoll.Connection interface.
func (m *MockNetConn) SetReadTimeout(timeout time.Duration) (e error) {
	if m.SetReadTimeoutFunc != nil {
		return m.SetReadTimeoutFunc(timeout)
	}
	return
}

// MockNetConnWriter implements netpoll.Writer
type MockNetConnWriter struct {
	FlushFunc       func() (err error)
	WriteDirectFunc func(p []byte, remainCap int) error
}

var _ netpoll.Writer = &MockNetConnWriter{}

// Flush implements the netpoll.Writer interface.
func (m *MockNetConnWriter) Flush() (err error) {
	if m.FlushFunc != nil {
		return m.FlushFunc()
	}
	return
}

// Malloc implements the netpoll.Writer interface.
func (m *MockNetConnWriter) Malloc(n int) (buf []byte, err error) {
	return
}

// MallocLen implements the netpoll.Writer interface.
func (m *MockNetConnWriter) MallocLen() (length int) {
	return
}

// MallocAck implements the netpoll.Writer interface.
func (m *MockNetConnWriter) MallocAck(n int) (err error) {
	return
}

// Append implements the netpoll.Writer interface.
func (m *MockNetConnWriter) Append(w netpoll.Writer) (err error) {
	return
}

// Write implements the netpoll.Writer interface.
func (m *MockNetConnWriter) Write(b []byte) (n int, err error) {
	return
}

// WriteString implements the netpoll.Writer interface.
func (m *MockNetConnWriter) WriteString(s string) (n int, err error) {
	return
}

// WriteBinary implements the netpoll.Writer interface.
func (m *MockNetConnWriter) WriteBinary(b []byte) (n int, err error) {
	return
}

// WriteDirect implements the netpoll.Writer interface.
func (m *MockNetConnWriter) WriteDirect(p []byte, remainCap int) (err error) {
	if m.WriteDirectFunc != nil {
		return m.WriteDirectFunc(p, remainCap)
	}
	return
}

// WriteByte implements the netpoll.Writer interface.
func (m *MockNetConnWriter) WriteByte(b byte) (err error) {
	return
}

// MockNetConnReader implements netpoll.Reader
type MockNetConnReader struct {
	ReleaseFunc func() (err error)
}

// Next implements the netpoll.Reader interface.
func (m *MockNetConnReader) Next(n int) (p []byte, err error) {
	return
}

// Peek implements the netpoll.Reader interface.
func (m *MockNetConnReader) Peek(n int) (buf []byte, err error) {
	return
}

// Until implements the netpoll.Reader interface.
func (m *MockNetConnReader) Until(b byte) (p []byte, err error) {
	return
}

// Skip implements the netpoll.Reader interface.
func (m *MockNetConnReader) Skip(n int) (err error) {
	return
}

// Release implements the netpoll.Reader interface.
func (m *MockNetConnReader) Release() (err error) {
	if m.ReleaseFunc != nil {
		return m.ReleaseFunc()
	}
	return
}

// Slice implements the netpoll.Reader interface.
func (m *MockNetConnReader) Slice(n int) (r netpoll.Reader, err error) {
	return
}

// Len implements the netpoll.Reader interface.
func (m *MockNetConnReader) Len() (length int) {
	return
}

// Read implements the netpoll.Reader interface.
func (m *MockNetConnReader) Read(b []byte) (n int, err error) {
	return
}

// ReadString implements the netpoll.Reader interface.
func (m *MockNetConnReader) ReadString(n int) (s string, err error) {
	return
}

// ReadBinary implements the netpoll.Reader interface.
func (m *MockNetConnReader) ReadBinary(n int) (p []byte, err error) {
	return
}

// ReadByte implements the netpoll.Reader interface.
func (m *MockNetConnReader) ReadByte() (b byte, err error) {
	return
}