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

     1  package client
     2  
     3  import (
     4  	"testing"
     5  )
     6  
     7  func TestZAdd(t *testing.T) {
     8  	r.Del("key")
     9  	n, err := r.ZAdd("key", 1.0, "foo")
    10  	if err != nil {
    11  		t.Error(err)
    12  	} else if n != 1 {
    13  		t.Fail()
    14  	}
    15  }
    16  
    17  func BenchmarkZAdd(b *testing.B) {
    18  	for i := 0; i < b.N; i++ {
    19  		r.ZAdd("key", 1.0, "foo")
    20  	}
    21  }
    22  
    23  func TestZAddVariadic(t *testing.T) {
    24  	r.Del("key")
    25  	pairs := map[string]float64{
    26  		"one":   1.0,
    27  		"two":   1.0,
    28  		"three": 3.0,
    29  	}
    30  	if n, err := r.ZAddVariadic("key", pairs); err != nil {
    31  		t.Error(err)
    32  	} else if n != 3 {
    33  		t.Fail()
    34  	}
    35  	if n, _ := r.ZAddVariadic("key", map[string]float64{"two": 2.0}); n != 0 {
    36  		t.Fail()
    37  	}
    38  }
    39  func BenchmarkZAddVariadic(b *testing.B) {
    40  	for i := 0; i < b.N; i++ {
    41  		pairs := map[string]float64{
    42  			"one":   1.0,
    43  			"two":   1.0,
    44  			"three": 3.0,
    45  		}
    46  		r.ZAddVariadic("key", pairs)
    47  	}
    48  }
    49  
    50  func TestZCard(t *testing.T) {
    51  	r.Del("key")
    52  	pairs := map[string]float64{
    53  		"one":   1.0,
    54  		"two":   1.0,
    55  		"three": 3.0,
    56  	}
    57  	r.ZAddVariadic("key", pairs)
    58  	if n, err := r.ZCard("key"); err != nil {
    59  		t.Error(err)
    60  	} else if n != 3 {
    61  		t.Fail()
    62  	}
    63  }
    64  
    65  func TestZCount(t *testing.T) {
    66  	r.Del("key")
    67  	pairs := map[string]float64{
    68  		"one":   1.0,
    69  		"two":   2.0,
    70  		"three": 3.0,
    71  	}
    72  	r.ZAddVariadic("key", pairs)
    73  	if n, err := r.ZCount("key", "-inf", "+inf"); err != nil {
    74  		t.Error(err)
    75  	} else if n != 3 {
    76  		t.Fail()
    77  	}
    78  	if n, _ := r.ZCount("key", "(1", "3"); n != 2 {
    79  		t.Fail()
    80  	}
    81  }
    82  
    83  func TestZIncrBy(t *testing.T) {
    84  	r.Del("key")
    85  	pairs := map[string]float64{
    86  		"one":   1.0,
    87  		"two":   1.0,
    88  		"three": 3.0,
    89  	}
    90  	r.ZAddVariadic("key", pairs)
    91  	if n, err := r.ZIncrBy("key", 1.0, "two"); err != nil {
    92  		t.Error(err)
    93  	} else if n != 2.0 {
    94  		t.Fail()
    95  	}
    96  }
    97  
    98  func TestZRange(t *testing.T) {
    99  	r.Del("key")
   100  	pairs := map[string]float64{
   101  		"one":   1.0,
   102  		"two":   2.0,
   103  		"three": 3.0,
   104  	}
   105  	r.ZAddVariadic("key", pairs)
   106  	if result, err := r.ZRange("key", 0, -1, false); err != nil {
   107  		t.Error(err)
   108  	} else if len(result) != 3 {
   109  		t.Fail()
   110  	} else if result[0] != "one" {
   111  		t.Fail()
   112  	}
   113  	if result, err := r.ZRange("key", -2, -1, true); err != nil {
   114  		t.Error(err)
   115  	} else if len(result) != 4 {
   116  		t.Fail()
   117  	} else if result[0] != "two" {
   118  		t.Fail()
   119  	} else if result[1] != "2" {
   120  		t.Fail()
   121  	}
   122  }
   123  
   124  func TestZRank(t *testing.T) {
   125  	r.Del("key")
   126  	pairs := map[string]float64{
   127  		"one":   1.0,
   128  		"two":   2.0,
   129  		"three": 3.0,
   130  	}
   131  	r.ZAddVariadic("key", pairs)
   132  	if n, err := r.ZRank("key", "three"); err != nil {
   133  		t.Error(err)
   134  	} else if n != 2 {
   135  		t.Fail()
   136  	}
   137  	if n, err := r.ZRank("key", "four"); err != nil {
   138  		t.Error(err)
   139  	} else if n >= 0 {
   140  		t.Fail()
   141  	}
   142  }
   143  
   144  func TestZRem(t *testing.T) {
   145  	r.Del("key")
   146  	pairs := map[string]float64{
   147  		"one":   1.0,
   148  		"two":   2.0,
   149  		"three": 3.0,
   150  	}
   151  	r.ZAddVariadic("key", pairs)
   152  	if n, err := r.ZRem("key", "three", "four"); err != nil {
   153  		t.Error(err)
   154  	} else if n != 1 {
   155  		t.Fail()
   156  	}
   157  }
   158  
   159  func TestZRemRangeByRank(t *testing.T) {
   160  	r.Del("key")
   161  	pairs := map[string]float64{
   162  		"one":   1.0,
   163  		"two":   2.0,
   164  		"three": 3.0,
   165  	}
   166  	r.ZAddVariadic("key", pairs)
   167  	if n, err := r.ZRemRangeByRank("key", 0, 1); err != nil {
   168  		t.Error(err)
   169  	} else if n != 2 {
   170  		t.Fail()
   171  	}
   172  }
   173  
   174  func TestZRemRangeByScore(t *testing.T) {
   175  	r.Del("key")
   176  	pairs := map[string]float64{
   177  		"one":   1.0,
   178  		"two":   2.0,
   179  		"three": 3.0,
   180  	}
   181  	r.ZAddVariadic("key", pairs)
   182  	if n, err := r.ZRemRangeByScore("key", "-inf", "(2"); err != nil {
   183  		t.Error(err)
   184  	} else if n != 1 {
   185  		t.Fail()
   186  	}
   187  }
   188  
   189  func TestZRevRange(t *testing.T) {
   190  	r.Del("key")
   191  	pairs := map[string]float64{
   192  		"one":   1.0,
   193  		"two":   2.0,
   194  		"three": 3.0,
   195  	}
   196  	r.ZAddVariadic("key", pairs)
   197  	if result, err := r.ZRevRange("key", 0, -1, false); err != nil {
   198  		t.Error(err)
   199  	} else if len(result) != 3 {
   200  		t.Fail()
   201  	} else if result[0] != "three" {
   202  		t.Fail()
   203  	}
   204  }
   205  
   206  func TestZRevRank(t *testing.T) {
   207  	r.Del("key")
   208  	pairs := map[string]float64{
   209  		"one":   1.0,
   210  		"two":   2.0,
   211  		"three": 3.0,
   212  	}
   213  	r.ZAddVariadic("key", pairs)
   214  	if n, err := r.ZRevRank("key", "three"); err != nil {
   215  		t.Error(err)
   216  	} else if n != 0 {
   217  		t.Fail()
   218  	}
   219  	if n, err := r.ZRevRank("key", "four"); err != nil {
   220  		t.Error(err)
   221  	} else if n >= 0 {
   222  		t.Fail()
   223  	}
   224  }
   225  
   226  func TestZScore(t *testing.T) {
   227  	r.Del("key")
   228  	pairs := map[string]float64{
   229  		"one":   1.0,
   230  		"two":   2.0,
   231  		"three": 3.0,
   232  	}
   233  	r.ZAddVariadic("key", pairs)
   234  	if result, err := r.ZScore("key", "member"); err != nil {
   235  		t.Error(err)
   236  	} else if result != nil {
   237  		t.Fail()
   238  	}
   239  	if result, err := r.ZScore("key", "two"); err != nil {
   240  		t.Error(err)
   241  	} else if string(result) != "2" {
   242  		t.Fail()
   243  	}
   244  }
   245  
   246  func TestZScan(t *testing.T) {
   247  	r.Del("key")
   248  	pairs := map[string]float64{
   249  		"one":   1.0,
   250  		"two":   2.0,
   251  		"three": 3.0,
   252  	}
   253  	r.ZAddVariadic("key", pairs)
   254  	if _, list, err := r.ZScan("key", 0, "", 0); err != nil {
   255  		t.Error(err)
   256  	} else if len(list) == 0 {
   257  		t.Fail()
   258  	}
   259  }
   260  
   261  func TestZInterStore(t *testing.T) {
   262  	r.Del("zset1", "zset2")
   263  	r.ZAddVariadic("zset1", map[string]float64{
   264  		"one": 1,
   265  		"two": 2,
   266  	})
   267  	r.ZAddVariadic("zset2", map[string]float64{
   268  		"one":   1,
   269  		"two":   2,
   270  		"three": 3,
   271  	})
   272  	if n, err := r.ZInterStore("out", []string{"zset1", "zset2"}, []int{2, 3}, ""); err != nil {
   273  		t.Error(err)
   274  	} else if n != 2 {
   275  		t.Fail()
   276  	}
   277  }
   278  
   279  func TestZUnionStore(t *testing.T) {
   280  	r.Del("zset1", "zset2")
   281  	r.ZAddVariadic("zset1", map[string]float64{
   282  		"one": 1,
   283  		"two": 2,
   284  	})
   285  	r.ZAddVariadic("zset2", map[string]float64{
   286  		"one":   1,
   287  		"two":   2,
   288  		"three": 3,
   289  	})
   290  	if n, err := r.ZUnionStore("out", []string{"zset1", "zset2"}, []int{2, 3}, ""); err != nil {
   291  		t.Error(err)
   292  	} else if n != 3 {
   293  		t.Fail()
   294  	}
   295  }
   296  
   297  func TestZRangeByScore(t *testing.T) {
   298  	r.Del("key")
   299  	r.ZAddVariadic("key", map[string]float64{
   300  		"one":   1,
   301  		"two":   2,
   302  		"three": 3,
   303  	})
   304  	if result, err := r.ZRangeByScore("key", "-inf", "+inf", false, false, 0, 0); err != nil {
   305  		t.Error(err)
   306  	} else if len(result) != 3 {
   307  		t.Fail()
   308  	}
   309  }
   310  
   311  func TestZRevRangeByScore(t *testing.T) {
   312  	r.Del("key")
   313  	r.ZAddVariadic("key", map[string]float64{
   314  		"one":   1,
   315  		"two":   2,
   316  		"three": 3,
   317  	})
   318  	if result, err := r.ZRevRangeByScore("key", "(2", "(1", false, false, 0, 0); err != nil {
   319  		t.Error(err)
   320  	} else if len(result) != 0 {
   321  		t.Fail()
   322  	}
   323  }