github.com/Finschia/ostracon@v1.1.5/rpc/jsonrpc/server/common_test.go (about)

     1  package server
     2  
     3  import (
     4  	"encoding/json"
     5  	"errors"
     6  	"fmt"
     7  	"net/http"
     8  	"strconv"
     9  
    10  	"github.com/Finschia/ostracon/libs/log"
    11  	"github.com/Finschia/ostracon/rpc/jsonrpc/types"
    12  )
    13  
    14  var (
    15  	TestJSONIntID = types.JSONRPCIntID(-1)
    16  	TestRPCError  = &types.RPCError{}
    17  	TestRawMSG    = json.RawMessage(`{"p1":"v1"}`)
    18  	TestText      = "foo"
    19  	ErrFoo        = errors.New(TestText)
    20  
    21  	TestRPCFunc = NewRPCFunc(
    22  		func(ctx *types.Context, s string, i int) (string, error) { return TestText, nil }, "s,i")
    23  	TestRPCErrorFunc = NewRPCFunc(
    24  		func(ctx *types.Context, s string, i int) (string, error) { return "", ErrFoo }, "s,i")
    25  	TestWSRPCFunc = NewWSRPCFunc(
    26  		func(ctx *types.Context, s string, i int) (string, error) { return TestText, nil }, "s,i")
    27  
    28  	TestFuncMap            = map[string]*RPCFunc{"c": TestRPCFunc}
    29  	TestGoodBody           = `{"jsonrpc": "2.0", "method": "c", "id": "0", "params": null}`
    30  	TestBadParams          = `{"jsonrpc": "2.0", "method": "c", "id": "0", "params": "s=a,i=b"}`
    31  	TestMaxBatchRequestNum = "10"
    32  )
    33  
    34  type FailManager struct {
    35  	counter       int
    36  	failedCounter int
    37  	throwPanic    bool
    38  }
    39  
    40  func (fm *FailManager) checkAndDo(
    41  	encounter func() (int, error),
    42  	throwing func(),
    43  ) (int, error) {
    44  	if fm.counter == fm.failedCounter {
    45  		fmt.Println("FailManager:do encounter")
    46  		return encounter()
    47  	}
    48  	fm.counter++
    49  	if fm.throwPanic {
    50  		fmt.Println("FailManager:do throwing")
    51  		throwing()
    52  	}
    53  	return 0, nil
    54  }
    55  
    56  type FailedWriteResponseWriter struct {
    57  	header http.Header
    58  	fm     *FailManager
    59  	code   int
    60  	error  error
    61  }
    62  
    63  func NewFailedWriteResponseWriter() FailedWriteResponseWriter {
    64  	return FailedWriteResponseWriter{
    65  		header: make(http.Header),
    66  		fm:     &FailManager{},
    67  		code:   -1,
    68  		error:  fmt.Errorf("error"),
    69  	}
    70  }
    71  func (frw FailedWriteResponseWriter) Header() http.Header {
    72  	return frw.header
    73  }
    74  func (frw FailedWriteResponseWriter) Write(buf []byte) (int, error) {
    75  	fmt.Println("FailedWriteResponseWriter:" + strconv.Itoa(frw.fm.counter) + ":" + string(buf))
    76  	return frw.fm.checkAndDo(
    77  		func() (int, error) {
    78  			return frw.code, frw.error
    79  		},
    80  		func() {
    81  			res := types.RPCResponse{}
    82  			res.UnmarshalJSON(buf) // nolint: errcheck
    83  			panic(res)
    84  		},
    85  	)
    86  }
    87  func (frw FailedWriteResponseWriter) WriteHeader(code int) {
    88  	frw.header.Set(http.StatusText(code), strconv.Itoa(code))
    89  }
    90  
    91  type FailedLogger struct {
    92  	fm *FailManager
    93  }
    94  
    95  func NewFailedLogger() FailedLogger {
    96  	return FailedLogger{
    97  		fm: &FailManager{},
    98  	}
    99  }
   100  func (l *FailedLogger) Info(msg string, keyvals ...interface{}) {
   101  	fmt.Println("FailedLogger.Info:" + msg)
   102  }
   103  func (l *FailedLogger) Debug(msg string, keyvals ...interface{}) {
   104  	fmt.Println("FailedLogger.Debug:" + msg)
   105  }
   106  func (l *FailedLogger) Error(msg string, keyvals ...interface{}) {
   107  	fmt.Println("FailedLogger.Error:" + strconv.Itoa(l.fm.counter) + ":" + msg)
   108  	l.fm.checkAndDo( // nolint: errcheck
   109  		func() (int, error) { panic(l.fm.counter) },
   110  		func() {},
   111  	)
   112  }
   113  func (l *FailedLogger) With(keyvals ...interface{}) log.Logger {
   114  	return l
   115  }