Example #1
0
func TestKVIncrDecr(t *testing.T) {
	c := getTestConn()
	defer c.Close()

	if n, err := ledis.Int64(c.Do("incr", "n")); err != nil {
		t.Fatal(err)
	} else if n != 1 {
		t.Fatal(n)
	}

	if n, err := ledis.Int64(c.Do("incr", "n")); err != nil {
		t.Fatal(err)
	} else if n != 2 {
		t.Fatal(n)
	}

	if n, err := ledis.Int64(c.Do("decr", "n")); err != nil {
		t.Fatal(err)
	} else if n != 1 {
		t.Fatal(n)
	}

	if n, err := ledis.Int64(c.Do("incrby", "n", 10)); err != nil {
		t.Fatal(err)
	} else if n != 11 {
		t.Fatal(n)
	}

	if n, err := ledis.Int64(c.Do("decrby", "n", 10)); err != nil {
		t.Fatal(err)
	} else if n != 1 {
		t.Fatal(n)
	}
}
Example #2
0
func TestZUnionStore(t *testing.T) {
	c := getTestConn()
	defer c.Close()

	if _, err := c.Do("zadd", "k1", "1", "one"); err != nil {
		t.Fatal(err.Error())
	}

	if _, err := c.Do("zadd", "k1", "2", "two"); err != nil {
		t.Fatal(err.Error())
	}

	if _, err := c.Do("zadd", "k2", "1", "two"); err != nil {
		t.Fatal(err.Error())
	}

	if _, err := c.Do("zadd", "k2", "2", "three"); err != nil {
		t.Fatal(err.Error())
	}

	if n, err := ledis.Int64(c.Do("zunionstore", "out", "2", "k1", "k2", "weights", "1", "2")); err != nil {
		t.Fatal(err.Error())
	} else {
		if n != 3 {
			t.Fatal("invalid value ", n)
		}
	}

	if n, err := ledis.Int64(c.Do("zunionstore", "out", "2", "k1", "k2", "weights", "1", "2", "aggregate", "min")); err != nil {
		t.Fatal(err.Error())
	} else {
		if n != 3 {
			t.Fatal("invalid value ", n)
		}
	}

	if n, err := ledis.Int64(c.Do("zunionstore", "out", "2", "k1", "k2", "aggregate", "max")); err != nil {
		t.Fatal(err.Error())
	} else {
		if n != 3 {
			t.Fatal("invalid value ", n)
		}
	}

	if n, err := ledis.Int64(c.Do("zscore", "out", "two")); err != nil {
		t.Fatal(err.Error())
	} else {
		if n != 2 {
			t.Fatal("invalid value ", n)
		}
	}
}
Example #3
0
func TestExpire(t *testing.T) {
	// test for kv, list, hash, set, zset, bitmap in all
	ttlType := []string{"k", "l", "h", "s", "z", "b"}

	var (
		expire   string
		expireat string
		ttl      string
		persist  string
		key      string
	)

	c := getTestConn()
	defer c.Close()

	idx := 1
	for _, tt := range ttlType {
		if tt == "k" {
			expire = "expire"
			expireat = "expireat"
			ttl = "ttl"
			persist = "persist"

		} else {
			expire = fmt.Sprintf("%sexpire", tt)
			expireat = fmt.Sprintf("%sexpireat", tt)
			ttl = fmt.Sprintf("%sttl", tt)
			persist = fmt.Sprintf("%spersist", tt)
		}

		switch tt {
		case "k":
			key = "kv_ttl"
			c.Do("set", key, "123")
		case "l":
			key = "list_ttl"
			c.Do("rpush", key, "123")
		case "h":
			key = "hash_ttl"
			c.Do("hset", key, "a", "123")
		case "s":
			key = "set_ttl"
			c.Do("sadd", key, "123")
		case "z":
			key = "zset_ttl"
			c.Do("zadd", key, 123, "a")
		case "b":
			key = "bitmap_ttl"
			c.Do("bsetbit", key, 0, 1)
		}

		//	expire + ttl
		exp := int64(10)
		if n, err := ledis.Int(c.Do(expire, key, exp)); err != nil {
			t.Fatal(err)
		} else if n != 1 {
			t.Fatal(n)
		}

		if ttl, err := ledis.Int64(c.Do(ttl, key)); err != nil {
			t.Fatal(err)
		} else if ttl != exp {
			t.Fatal(ttl)
		}

		//	expireat + ttl
		tm := now() + 3
		if n, err := ledis.Int(c.Do(expireat, key, tm)); err != nil {
			t.Fatal(err)
		} else if n != 1 {
			t.Fatal(n)
		}

		if ttl, err := ledis.Int64(c.Do(ttl, key)); err != nil {
			t.Fatal(err)
		} else if ttl != 3 {
			t.Fatal(ttl)
		}

		kErr := "not_exist_ttl"

		//	err - expire, expireat
		if n, err := ledis.Int(c.Do(expire, kErr, tm)); err != nil || n != 0 {
			t.Fatal(false)
		}

		if n, err := ledis.Int(c.Do(expireat, kErr, tm)); err != nil || n != 0 {
			t.Fatal(false)
		}

		if n, err := ledis.Int(c.Do(ttl, kErr)); err != nil || n != -1 {
			t.Fatal(false)
		}

		if n, err := ledis.Int(c.Do(persist, key)); err != nil {
			t.Fatal(err)
		} else if n != 1 {
			t.Fatal(n)
		}

		if n, err := ledis.Int(c.Do(expire, key, 10)); err != nil {
			t.Fatal(err)
		} else if n != 1 {
			t.Fatal(n)
		}

		if n, err := ledis.Int(c.Do(persist, key)); err != nil {
			t.Fatal(err)
		} else if n != 1 {
			t.Fatal(n)
		}

		idx++
	}

}
Example #4
0
func TestSetExpire(t *testing.T) {
	c := getTestConn()
	defer c.Close()

	k := "set_ttl"
	c.Do("sadd", k, "123")

	//	expire + ttl
	exp := int64(10)
	if n, err := ledis.Int(c.Do("sexpire", k, exp)); err != nil {
		t.Fatal(err)
	} else if n != 1 {
		t.Fatal(n)
	}

	if ttl, err := ledis.Int64(c.Do("sttl", k)); err != nil {
		t.Fatal(err)
	} else if ttl != exp {
		t.Fatal(ttl)
	}

	//	expireat + ttl
	tm := now() + 3
	if n, err := ledis.Int(c.Do("sexpireat", k, tm)); err != nil {
		t.Fatal(err)
	} else if n != 1 {
		t.Fatal(n)
	}

	if ttl, err := ledis.Int64(c.Do("sttl", k)); err != nil {
		t.Fatal(err)
	} else if ttl != 3 {
		t.Fatal(ttl)
	}

	kErr := "not_exist_ttl"

	//	err - expire, expireat
	if n, err := ledis.Int(c.Do("sexpire", kErr, tm)); err != nil || n != 0 {
		t.Fatal(false)
	}

	if n, err := ledis.Int(c.Do("sexpireat", kErr, tm)); err != nil || n != 0 {
		t.Fatal(false)
	}

	if n, err := ledis.Int(c.Do("sttl", kErr)); err != nil || n != -1 {
		t.Fatal(false)
	}

	if n, err := ledis.Int(c.Do("spersist", k)); err != nil {
		t.Fatal(err)
	} else if n != 1 {
		t.Fatal(n)
	}

	if n, err := ledis.Int(c.Do("sexpire", k, 10)); err != nil {
		t.Fatal(err)
	} else if n != 1 {
		t.Fatal(n)
	}

	if n, err := ledis.Int(c.Do("spersist", k)); err != nil {
		t.Fatal(err)
	} else if n != 1 {
		t.Fatal(n)
	}

}