reply_test.go

Documentation: github.com/gomodule/redigo/redis

     1  // Copyright 2012 Gary Burd
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License"): you may
     4  // not use this file except in compliance with the License. You may obtain
     5  // a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
    11  // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
    12  // License for the specific language governing permissions and limitations
    13  // under the License.
    14  
    15  package redis_test
    16  
    17  import (
    18  	"fmt"
    19  	"reflect"
    20  	"testing"
    21  
    22  	"github.com/gomodule/redigo/redis"
    23  )
    24  
    25  type valueError struct {
    26  	v   interface{}
    27  	err error
    28  }
    29  
    30  func ve(v interface{}, err error) valueError {
    31  	return valueError{v, err}
    32  }
    33  
    34  var replyTests = []struct {
    35  	name     interface{}
    36  	actual   valueError
    37  	expected valueError
    38  }{
    39  	{
    40  		"ints([[]byte, []byte])",
    41  		ve(redis.Ints([]interface{}{[]byte("4"), []byte("5")}, nil)),
    42  		ve([]int{4, 5}, nil),
    43  	},
    44  	{
    45  		"ints([nt64, int64])",
    46  		ve(redis.Ints([]interface{}{int64(4), int64(5)}, nil)),
    47  		ve([]int{4, 5}, nil),
    48  	},
    49  	{
    50  		"ints([[]byte, nil, []byte])",
    51  		ve(redis.Ints([]interface{}{[]byte("4"), nil, []byte("5")}, nil)),
    52  		ve([]int{4, 0, 5}, nil),
    53  	},
    54  	{
    55  		"ints(nil)",
    56  		ve(redis.Ints(nil, nil)),
    57  		ve([]int(nil), redis.ErrNil),
    58  	},
    59  	{
    60  		"int64s([[]byte, []byte])",
    61  		ve(redis.Int64s([]interface{}{[]byte("4"), []byte("5")}, nil)),
    62  		ve([]int64{4, 5}, nil),
    63  	},
    64  	{
    65  		"int64s([int64, int64])",
    66  		ve(redis.Int64s([]interface{}{int64(4), int64(5)}, nil)),
    67  		ve([]int64{4, 5}, nil),
    68  	},
    69  	{
    70  		"strings([[]byte, []bytev2])",
    71  		ve(redis.Strings([]interface{}{[]byte("v1"), []byte("v2")}, nil)),
    72  		ve([]string{"v1", "v2"}, nil),
    73  	},
    74  	{
    75  		"strings([string, string])",
    76  		ve(redis.Strings([]interface{}{"v1", "v2"}, nil)),
    77  		ve([]string{"v1", "v2"}, nil),
    78  	},
    79  	{
    80  		"byteslices([v1, v2])",
    81  		ve(redis.ByteSlices([]interface{}{[]byte("v1"), []byte("v2")}, nil)),
    82  		ve([][]byte{[]byte("v1"), []byte("v2")}, nil),
    83  	},
    84  	{
    85  		"float64s([v1, v2])",
    86  		ve(redis.Float64s([]interface{}{[]byte("1.234"), []byte("5.678")}, nil)),
    87  		ve([]float64{1.234, 5.678}, nil),
    88  	},
    89  	{
    90  		"values([v1, v2])",
    91  		ve(redis.Values([]interface{}{[]byte("v1"), []byte("v2")}, nil)),
    92  		ve([]interface{}{[]byte("v1"), []byte("v2")}, nil),
    93  	},
    94  	{
    95  		"values(nil)",
    96  		ve(redis.Values(nil, nil)),
    97  		ve([]interface{}(nil), redis.ErrNil),
    98  	},
    99  	{
   100  		"float64(1.0)",
   101  		ve(redis.Float64([]byte("1.0"), nil)),
   102  		ve(float64(1.0), nil),
   103  	},
   104  	{
   105  		"float64(nil)",
   106  		ve(redis.Float64(nil, nil)),
   107  		ve(float64(0.0), redis.ErrNil),
   108  	},
   109  	{
   110  		"uint64(1)",
   111  		ve(redis.Uint64(int64(1), nil)),
   112  		ve(uint64(1), nil),
   113  	},
   114  	{
   115  		"uint64(-1)",
   116  		ve(redis.Uint64(int64(-1), nil)),
   117  		ve(uint64(0), redis.ErrNegativeInt),
   118  	},
   119  	{
   120  		"positions([[1, 2], nil, [3, 4]])",
   121  		ve(redis.Positions([]interface{}{[]interface{}{[]byte("1"), []byte("2")}, nil, []interface{}{[]byte("3"), []byte("4")}}, nil)),
   122  		ve([]*[2]float64{{1.0, 2.0}, nil, {3.0, 4.0}}, nil),
   123  	},
   124  }
   125  
   126  func TestReply(t *testing.T) {
   127  	for _, rt := range replyTests {
   128  		if rt.actual.err != rt.expected.err {
   129  			t.Errorf("%s returned err %v, want %v", rt.name, rt.actual.err, rt.expected.err)
   130  			continue
   131  		}
   132  		if !reflect.DeepEqual(rt.actual.v, rt.expected.v) {
   133  			t.Errorf("%s=%+v, want %+v", rt.name, rt.actual.v, rt.expected.v)
   134  		}
   135  	}
   136  }
   137  
   138  // dial wraps DialDefaultServer() with a more suitable function name for examples.
   139  func dial() (redis.Conn, error) {
   140  	return redis.DialDefaultServer()
   141  }
   142  
   143  // serverAddr wraps DefaultServerAddr() with a more suitable function name for examples.
   144  func serverAddr() (string, error) {
   145  	return redis.DefaultServerAddr()
   146  }
   147  
   148  func ExampleBool() {
   149  	c, err := dial()
   150  	if err != nil {
   151  		fmt.Println(err)
   152  		return
   153  	}
   154  	defer c.Close()
   155  
   156  	c.Do("SET", "foo", 1)
   157  	exists, _ := redis.Bool(c.Do("EXISTS", "foo"))
   158  	fmt.Printf("%#v\n", exists)
   159  	// Output:
   160  	// true
   161  }
   162  
   163  func ExampleInt() {
   164  	c, err := dial()
   165  	if err != nil {
   166  		fmt.Println(err)
   167  		return
   168  	}
   169  	defer c.Close()
   170  
   171  	c.Do("SET", "k1", 1)
   172  	n, _ := redis.Int(c.Do("GET", "k1"))
   173  	fmt.Printf("%#v\n", n)
   174  	n, _ = redis.Int(c.Do("INCR", "k1"))
   175  	fmt.Printf("%#v\n", n)
   176  	// Output:
   177  	// 1
   178  	// 2
   179  }
   180  
   181  func ExampleInts() {
   182  	c, err := dial()
   183  	if err != nil {
   184  		fmt.Println(err)
   185  		return
   186  	}
   187  	defer c.Close()
   188  
   189  	c.Do("SADD", "set_with_integers", 4, 5, 6)
   190  	ints, _ := redis.Ints(c.Do("SMEMBERS", "set_with_integers"))
   191  	fmt.Printf("%#v\n", ints)
   192  	// Output:
   193  	// []int{4, 5, 6}
   194  }
   195  
   196  func ExampleString() {
   197  	c, err := dial()
   198  	if err != nil {
   199  		fmt.Println(err)
   200  		return
   201  	}
   202  	defer c.Close()
   203  
   204  	c.Do("SET", "hello", "world")
   205  	s, err := redis.String(c.Do("GET", "hello"))
   206  	fmt.Printf("%#v\n", s)
   207  	// Output:
   208  	// "world"
   209  }
   210
View as plain text