github.com/hdt3213/godis@v1.2.9/redis/parser/parser_test.go (about)

     1  package parser
     2  
     3  import (
     4  	"bytes"
     5  	"github.com/hdt3213/godis/interface/redis"
     6  	"github.com/hdt3213/godis/lib/utils"
     7  	"github.com/hdt3213/godis/redis/protocol"
     8  	"io"
     9  	"testing"
    10  )
    11  
    12  func TestParseStream(t *testing.T) {
    13  	replies := []redis.Reply{
    14  		protocol.MakeIntReply(1),
    15  		protocol.MakeStatusReply("OK"),
    16  		protocol.MakeErrReply("ERR unknown"),
    17  		protocol.MakeBulkReply([]byte("a\r\nb")), // test binary safe
    18  		protocol.MakeNullBulkReply(),
    19  		protocol.MakeMultiBulkReply([][]byte{
    20  			[]byte("a"),
    21  			[]byte("\r\n"),
    22  		}),
    23  		protocol.MakeEmptyMultiBulkReply(),
    24  	}
    25  	reqs := bytes.Buffer{}
    26  	for _, re := range replies {
    27  		reqs.Write(re.ToBytes())
    28  	}
    29  	reqs.Write([]byte("set a a" + protocol.CRLF)) // test text protocol
    30  	expected := make([]redis.Reply, len(replies))
    31  	copy(expected, replies)
    32  	expected = append(expected, protocol.MakeMultiBulkReply([][]byte{
    33  		[]byte("set"), []byte("a"), []byte("a"),
    34  	}))
    35  
    36  	ch := ParseStream(bytes.NewReader(reqs.Bytes()))
    37  	i := 0
    38  	for payload := range ch {
    39  		if payload.Err != nil {
    40  			if payload.Err == io.EOF {
    41  				return
    42  			}
    43  			t.Error(payload.Err)
    44  			return
    45  		}
    46  		if payload.Data == nil {
    47  			t.Error("empty data")
    48  			return
    49  		}
    50  		exp := expected[i]
    51  		i++
    52  		if !utils.BytesEquals(exp.ToBytes(), payload.Data.ToBytes()) {
    53  			t.Error("parse failed: " + string(exp.ToBytes()))
    54  		}
    55  	}
    56  }
    57  
    58  func TestParseOne(t *testing.T) {
    59  	replies := []redis.Reply{
    60  		protocol.MakeIntReply(1),
    61  		protocol.MakeStatusReply("OK"),
    62  		protocol.MakeErrReply("ERR unknown"),
    63  		protocol.MakeBulkReply([]byte("a\r\nb")), // test binary safe
    64  		protocol.MakeNullBulkReply(),
    65  		protocol.MakeMultiBulkReply([][]byte{
    66  			[]byte("a"),
    67  			[]byte("\r\n"),
    68  		}),
    69  		protocol.MakeEmptyMultiBulkReply(),
    70  	}
    71  	for _, re := range replies {
    72  		result, err := ParseOne(re.ToBytes())
    73  		if err != nil {
    74  			t.Error(err)
    75  			continue
    76  		}
    77  		if !utils.BytesEquals(result.ToBytes(), re.ToBytes()) {
    78  			t.Error("parse failed: " + string(re.ToBytes()))
    79  		}
    80  	}
    81  }