github.com/therealbill/libredis@v0.0.0-20161227004305-7d50abda5ccf/client/keys_test.go (about)

     1  package client
     2  
     3  import (
     4  	"testing"
     5  	"time"
     6  )
     7  
     8  func TestDel(t *testing.T) {
     9  	r.Set("key", "value")
    10  	if n, err := r.Del("key"); err != nil {
    11  		t.Error(err)
    12  	} else if n != 1 {
    13  		t.Fail()
    14  	}
    15  }
    16  
    17  func TestDump(t *testing.T) {
    18  	r.Set("key", "value")
    19  	data, err := r.Dump("key")
    20  	if err != nil {
    21  		t.Error(err)
    22  	}
    23  	if data == nil || len(data) == 0 {
    24  		t.Fail()
    25  	}
    26  }
    27  
    28  func TestExists(t *testing.T) {
    29  	r.Del("key")
    30  	b, err := r.Exists("key")
    31  	if err != nil {
    32  		t.Error(err)
    33  	}
    34  	if b {
    35  		t.Fail()
    36  	}
    37  }
    38  
    39  func TestExpire(t *testing.T) {
    40  	r.Set("key", "value")
    41  	if b, err := r.Expire("key", 10); err != nil {
    42  		t.Error(err)
    43  	} else if !b {
    44  		t.Fail()
    45  	}
    46  	if n, err := r.TTL("key"); err != nil {
    47  		t.Error(err)
    48  	} else if n != 10 {
    49  		t.Fail()
    50  	}
    51  }
    52  
    53  func TestExpireAt(t *testing.T) {
    54  	r.Set("key", "value")
    55  	if b, err := r.ExpireAt("key", time.Now().Add(10*time.Second).Unix()); err != nil {
    56  		t.Error(err)
    57  	} else if !b {
    58  		t.Fail()
    59  	}
    60  	if n, err := r.TTL("key"); err != nil {
    61  		t.Error(err)
    62  	} else if n < 0 {
    63  		t.Fail()
    64  	}
    65  }
    66  
    67  func TestKeys(t *testing.T) {
    68  	r.FlushDB()
    69  	keys, err := r.Keys("*")
    70  	if err != nil {
    71  		t.Error(err)
    72  	}
    73  	if len(keys) != 0 {
    74  		t.Fail()
    75  	}
    76  	r.Set("key", "value")
    77  	keys, err = r.Keys("*")
    78  	if err != nil {
    79  		t.Error(err)
    80  	}
    81  	if len(keys) != 1 || keys[0] != "key" {
    82  		t.Fail()
    83  	}
    84  }
    85  
    86  func TestMove(t *testing.T) {
    87  	r.Set("key", "value")
    88  	if _, err := r.Move("key", db+1); err != nil {
    89  		t.Error(err)
    90  	}
    91  }
    92  
    93  func TestObject(t *testing.T) {
    94  	r.Del("key")
    95  	r.LPush("key", "hello world")
    96  	if rp, err := r.Object("refcount", "key"); err != nil {
    97  		t.Error(err)
    98  	} else if rp.Type != IntegerReply {
    99  		t.Fail()
   100  	}
   101  	if rp, err := r.Object("encoding", "key"); err != nil {
   102  		t.Error(err)
   103  	} else if rp.Type != BulkReply {
   104  		t.Fail()
   105  	}
   106  	if rp, err := r.Object("idletime", "key"); err != nil {
   107  		t.Error(err)
   108  	} else if rp.Type != IntegerReply {
   109  		t.Fail()
   110  	}
   111  }
   112  
   113  func TestPersist(t *testing.T) {
   114  	r.Set("key", "value")
   115  	r.Expire("key", 500)
   116  	if n, _ := r.TTL("key"); n < 0 {
   117  		t.Fail()
   118  	}
   119  	if b, err := r.Persist("key"); err != nil {
   120  		t.Error(err)
   121  	} else if !b {
   122  		t.Fail()
   123  	}
   124  	if n, _ := r.TTL("key"); n > 0 {
   125  		t.Fail()
   126  	}
   127  }
   128  
   129  func TestPExpire(t *testing.T) {
   130  	r.Set("key", "value")
   131  	if b, err := r.PExpire("key", 100); err != nil {
   132  		t.Error(err)
   133  	} else if !b {
   134  		t.Fail()
   135  	}
   136  }
   137  
   138  func TestPExpireAt(t *testing.T) {
   139  	r.Set("key", "value")
   140  	if b, err := r.PExpireAt("key", time.Now().Add(500*time.Second).Unix()*1000); err != nil {
   141  		t.Error(err)
   142  	} else if !b {
   143  		t.Fail()
   144  	}
   145  }
   146  
   147  func TestPTTL(t *testing.T) {
   148  	r.Set("key", "value")
   149  	r.PExpire("key", 1000)
   150  	if n, err := r.PTTL("key"); err != nil {
   151  		t.Error(err)
   152  	} else if n < 0 {
   153  		t.Fail()
   154  	}
   155  }
   156  
   157  func TestRandomKey(t *testing.T) {
   158  	r.FlushDB()
   159  	key, err := r.RandomKey()
   160  	if err != nil {
   161  		t.Error(err)
   162  	}
   163  	if key != nil {
   164  		t.Fail()
   165  	}
   166  	r.Set("key", "value")
   167  	key, _ = r.RandomKey()
   168  	if string(key) != "key" {
   169  		t.Fail()
   170  	}
   171  }
   172  
   173  func TestRename(t *testing.T) {
   174  	r.Set("key", "value")
   175  	if err := r.Rename("key", "newkey"); err != nil {
   176  		t.Error(err)
   177  	}
   178  	b, _ := r.Exists("key")
   179  	if b {
   180  		t.Fail()
   181  	}
   182  	v, _ := r.Get("newkey")
   183  	if string(v) != "value" {
   184  		t.Fail()
   185  	}
   186  }
   187  
   188  func TestRenamenx(t *testing.T) {
   189  	r.Set("key", "value")
   190  	r.Set("newkey", "value")
   191  	if b, err := r.Renamenx("key", "newkey"); err != nil {
   192  		t.Error(err)
   193  	} else if b {
   194  		t.Fail()
   195  	}
   196  }
   197  
   198  func TestRestore(t *testing.T) {
   199  	r.Set("key", "value")
   200  	data, _ := r.Dump("key")
   201  	r.Del("key")
   202  	if err := r.Restore("key", 0, string(data)); err != nil {
   203  		t.Error(err)
   204  	}
   205  }
   206  
   207  func TestTTL(t *testing.T) {
   208  	r.Set("key", "value")
   209  	r.Expire("key", 100)
   210  	n, err := r.TTL("key")
   211  	if err != nil {
   212  		t.Error(err)
   213  	}
   214  	if n < 0 {
   215  		t.Fail()
   216  	}
   217  	r.Persist("key")
   218  	n, _ = r.TTL("key")
   219  	if n > 0 {
   220  		t.Fail()
   221  	}
   222  }
   223  
   224  func TestType(t *testing.T) {
   225  	r.Set("key", "value")
   226  	ty, err := r.Type("key")
   227  	if err != nil {
   228  		t.Error(err)
   229  	}
   230  	if ty != "string" {
   231  		t.Fail()
   232  	}
   233  }
   234  
   235  func TestScan(t *testing.T) {
   236  	r.FlushDB()
   237  	cursor, list, err := r.Scan(0, "", 0)
   238  	if err != nil {
   239  		t.Error(err)
   240  	} else if len(list) != 0 {
   241  		t.Fail()
   242  	} else if cursor != 0 {
   243  		t.Fail()
   244  	}
   245  }