github.com/cellofellow/gopkg@v0.0.0-20140722061823-eec0544a62ad/database/redis/reply_test.go (about)

     1  // Copyright 2014 <chaishushan{AT}gmail.com>. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package redis
     6  
     7  import (
     8  	. "chai2010.gopkg/check"
     9  )
    10  
    11  type ReplySuite struct{}
    12  
    13  var _ = Suite(&ReplySuite{})
    14  
    15  func (s *ReplySuite) TestStr(c *C) {
    16  	r := &Reply{Type: ErrorReply, Err: ParseError}
    17  	_, err := r.Str()
    18  	c.Check(err, Equals, ParseError)
    19  
    20  	r = &Reply{Type: IntegerReply}
    21  	_, err = r.Str()
    22  	c.Check(err, NotNil)
    23  
    24  	r = &Reply{Type: StatusReply, buf: []byte("foo")}
    25  	b, err := r.Str()
    26  	c.Check(err, IsNil)
    27  	c.Check(b, Equals, "foo")
    28  
    29  	r = &Reply{Type: BulkReply, buf: []byte("foo")}
    30  	b, err = r.Str()
    31  	c.Check(err, IsNil)
    32  	c.Check(b, Equals, "foo")
    33  }
    34  
    35  func (s *ReplySuite) TestBytes(c *C) {
    36  	r := &Reply{Type: BulkReply, buf: []byte("foo")}
    37  	b, err := r.Bytes()
    38  	c.Check(err, IsNil)
    39  	c.Check(b, DeepEquals, []byte("foo"))
    40  }
    41  
    42  func (s *ReplySuite) TestInt64(c *C) {
    43  	r := &Reply{Type: ErrorReply, Err: ParseError}
    44  	_, err := r.Int64()
    45  	c.Check(err, Equals, ParseError)
    46  
    47  	r = &Reply{Type: IntegerReply, int: 5}
    48  	b, err := r.Int64()
    49  	c.Check(err, IsNil)
    50  	c.Check(b, Equals, int64(5))
    51  
    52  	r = &Reply{Type: BulkReply, buf: []byte("5")}
    53  	b, err = r.Int64()
    54  	c.Check(err, IsNil)
    55  	c.Check(b, Equals, int64(5))
    56  
    57  	r = &Reply{Type: BulkReply, buf: []byte("foo")}
    58  	_, err = r.Int64()
    59  	c.Check(err, NotNil)
    60  }
    61  
    62  func (s *ReplySuite) TestInt(c *C) {
    63  	r := &Reply{Type: IntegerReply, int: 5}
    64  	b, err := r.Int()
    65  	c.Check(err, IsNil)
    66  	c.Check(b, Equals, 5)
    67  }
    68  
    69  func (s *ReplySuite) TestBool(c *C) {
    70  	r := &Reply{Type: IntegerReply, int: 0}
    71  	b, err := r.Bool()
    72  	c.Check(err, IsNil)
    73  	c.Check(b, Equals, false)
    74  
    75  	r = &Reply{Type: StatusReply, buf: []byte("0")}
    76  	b, err = r.Bool()
    77  	c.Check(err, IsNil)
    78  	c.Check(b, Equals, false)
    79  
    80  	r = &Reply{Type: IntegerReply, int: 2}
    81  	b, err = r.Bool()
    82  	c.Check(err, IsNil)
    83  	c.Check(b, Equals, true)
    84  
    85  	r = &Reply{Type: NilReply}
    86  	_, err = r.Bool()
    87  	c.Check(err, NotNil)
    88  }
    89  
    90  func (s *ReplySuite) TestList(c *C) {
    91  	r := &Reply{Type: MultiReply}
    92  	r.Elems = make([]*Reply, 3)
    93  	r.Elems[0] = &Reply{Type: BulkReply, buf: []byte("0")}
    94  	r.Elems[1] = &Reply{Type: NilReply}
    95  	r.Elems[2] = &Reply{Type: BulkReply, buf: []byte("2")}
    96  	l, err := r.List()
    97  	c.Assert(err, IsNil)
    98  	c.Assert(len(l), Equals, 3)
    99  	c.Check(l[0], Equals, "0")
   100  	c.Check(l[1], Equals, "")
   101  	c.Check(l[2], Equals, "2")
   102  }
   103  
   104  func (s *ReplySuite) TestBytesList(c *C) {
   105  	r := &Reply{Type: MultiReply}
   106  	r.Elems = make([]*Reply, 3)
   107  	r.Elems[0] = &Reply{Type: BulkReply, buf: []byte("0")}
   108  	r.Elems[1] = &Reply{Type: NilReply}
   109  	r.Elems[2] = &Reply{Type: BulkReply, buf: []byte("2")}
   110  	l, err := r.ListBytes()
   111  	c.Assert(err, IsNil)
   112  	c.Assert(len(l), Equals, 3)
   113  	c.Check(l[0], DeepEquals, []byte("0"))
   114  	c.Assert(l[1], IsNil)
   115  	c.Check(l[2], DeepEquals, []byte("2"))
   116  }
   117  
   118  func (s *ReplySuite) TestHash(c *C) {
   119  	r := &Reply{Type: MultiReply}
   120  	r.Elems = make([]*Reply, 6)
   121  	r.Elems[0] = &Reply{Type: BulkReply, buf: []byte("a")}
   122  	r.Elems[1] = &Reply{Type: BulkReply, buf: []byte("0")}
   123  	r.Elems[2] = &Reply{Type: BulkReply, buf: []byte("b")}
   124  	r.Elems[3] = &Reply{Type: NilReply}
   125  	r.Elems[4] = &Reply{Type: BulkReply, buf: []byte("c")}
   126  	r.Elems[5] = &Reply{Type: BulkReply, buf: []byte("2")}
   127  	h, err := r.Hash()
   128  	c.Assert(err, IsNil)
   129  	c.Check(h["a"], Equals, "0")
   130  	c.Check(h["b"], Equals, "")
   131  	c.Check(h["c"], Equals, "2")
   132  }