PageRenderTime 34ms CodeModel.GetById 15ms RepoModel.GetById 0ms app.codeStats 0ms

/redis/commands_test.go

https://gitlab.com/sika-forks/go-redis
Go | 975 lines | 804 code | 86 blank | 85 comment | 410 complexity | 58d8cbe0d4776069fa904680a20d02f5 MD5 | raw file
Possible License(s): Apache-2.0
  1. // Copyright 2013 go-redis authors
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain 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,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  14. package redis
  15. import (
  16. "fmt"
  17. "math/rand"
  18. "strconv"
  19. "strings"
  20. "testing"
  21. "time"
  22. )
  23. // TODO: sort tests by dependency (set first, etc)
  24. // rc is the redis client handler used for all tests.
  25. // Make sure redis-server is running before starting the tests.
  26. var rc *Client
  27. func init() {
  28. rc = New("127.0.0.1:6379")
  29. rand.Seed(time.Now().UTC().UnixNano())
  30. }
  31. func randomString(l int) string {
  32. bytes := make([]byte, l)
  33. for i := 0; i < l; i++ {
  34. bytes[i] = byte(randInt(65, 90))
  35. }
  36. return string(bytes)
  37. }
  38. func randInt(min int, max int) int {
  39. return min + rand.Intn(max-min)
  40. }
  41. func errUnexpected(msg interface{}) string {
  42. return fmt.Sprintf("Unexpected response from redis-server: %#v\n", msg)
  43. }
  44. // Tests
  45. func TestPublish(t *testing.T) {
  46. k := randomString(16)
  47. v := randomString(16)
  48. if err := rc.Publish(k, v); err != nil {
  49. t.Error(err)
  50. return
  51. }
  52. }
  53. // TestAppend appends " World" to "Hello" and expects the lenght to be 11.
  54. func TestAppend(t *testing.T) {
  55. defer func() { rc.Del("foobar") }()
  56. if _, err := rc.Append("foobar", "Hello"); err != nil {
  57. t.Error(err)
  58. return
  59. }
  60. if n, err := rc.Append("foobar", " World"); err != nil {
  61. t.Error(err)
  62. } else if n != 11 {
  63. t.Error(errUnexpected(n))
  64. }
  65. }
  66. // TestBgRewriteAOF starts an Append Only File rewrite process.
  67. func __TestBgRewriteAOF(t *testing.T) {
  68. if status, err := rc.BgRewriteAOF(); err != nil {
  69. t.Error(err)
  70. } else if status != "Background append only file rewriting started" {
  71. t.Error(errUnexpected(status))
  72. }
  73. }
  74. // TestBgSave saves the DB in background.
  75. func __TestBgSave(t *testing.T) {
  76. if status, err := rc.BgSave(); err != nil {
  77. t.Error(err)
  78. } else if status != "Background saving started" {
  79. t.Error(errUnexpected(status))
  80. }
  81. }
  82. // TestBitCount reproduces the example from http://redis.io/commands/bitcount.
  83. func TestBitCount(t *testing.T) {
  84. defer func() { rc.Del("mykey") }()
  85. if err := rc.Set("mykey", "foobar"); err != nil {
  86. t.Error(err)
  87. return
  88. }
  89. if n, err := rc.BitCount("mykey", -1, -1); err != nil {
  90. t.Error(err)
  91. } else if n != 26 {
  92. t.Error(errUnexpected(n))
  93. }
  94. }
  95. // TestBitOp reproduces the example from http://redis.io/commands/bitop.
  96. func TestBitOp(t *testing.T) {
  97. defer func() { rc.Del("key1", "key2") }()
  98. if err := rc.Set("key1", "foobar"); err != nil {
  99. t.Error(err)
  100. return
  101. }
  102. if err := rc.Set("key2", "abcdef"); err != nil {
  103. t.Error(err)
  104. return
  105. }
  106. if _, err := rc.BitOp("and", "dest", "key1", "key2"); err != nil {
  107. t.Error(err)
  108. }
  109. }
  110. // TestRPush and LIndex
  111. func TestRPush(t *testing.T) {
  112. rc.Del("list1")
  113. rc.RPush("list1", "a", "b", "c")
  114. if v, err := rc.LIndex("list1", 1); err != nil {
  115. t.Error(err)
  116. } else if v != "b" {
  117. t.Error(errUnexpected("v=" + v))
  118. }
  119. rc.Del("list1")
  120. }
  121. // Test RPop
  122. func TestRPop(t *testing.T) {
  123. rc.Del("list1")
  124. rc.RPush("list1", "a", "b", "c")
  125. if v, err := rc.RPop("list1"); err != nil {
  126. t.Error(err)
  127. } else if v != "c" {
  128. t.Error(errUnexpected("v=" + v))
  129. }
  130. rc.Del("list1")
  131. }
  132. // Test LPop
  133. func TestLPop(t *testing.T) {
  134. rc.Del("list1")
  135. rc.RPush("list1", "a", "b", "c")
  136. if v, err := rc.LPop("list1"); err != nil {
  137. t.Error(err)
  138. } else if v != "a" {
  139. t.Error(errUnexpected("v=" + v))
  140. }
  141. rc.Del("list1")
  142. }
  143. func TestLLen(t *testing.T) {
  144. rc.Del("list1")
  145. rc.RPush("list1", "a", "b", "c")
  146. if v, err := rc.LLen("list1"); err != nil {
  147. t.Error(err)
  148. } else if v != 3 {
  149. t.Error(errUnexpected("v=" + string(v)))
  150. }
  151. rc.Del("list1")
  152. }
  153. func TestLTrim(t *testing.T) {
  154. rc.Del("list1")
  155. rc.RPush("list1", "a", "b", "c", "d")
  156. if err := rc.LTrim("list1", 2, 3); err != nil {
  157. t.Error(err)
  158. }
  159. if v, err := rc.LLen("list1"); err != nil {
  160. t.Error(err)
  161. } else if v != 2 {
  162. t.Error(errUnexpected("len list1 =" + string(v)))
  163. }
  164. rc.Del("list1")
  165. }
  166. func TestLRange(t *testing.T) {
  167. rc.Del("list1")
  168. rc.RPush("list1", "a", "b", "c", "d")
  169. if v, err := rc.LRange("list1", 0, 1); err != nil {
  170. t.Error(err)
  171. } else if v[0] != "a" {
  172. t.Error(errUnexpected("LRange list1"))
  173. }
  174. rc.Del("list1")
  175. }
  176. // TestBLPop reproduces the example from http://redis.io/commands/blpop.
  177. func TestBLPop(t *testing.T) {
  178. rc.Del("list1", "list2")
  179. rc.RPush("list1", "a", "b", "c")
  180. if k, v, err := rc.BLPop(0, "list1", "list2"); err != nil {
  181. t.Error(err)
  182. } else if k != "list1" || v != "a" {
  183. t.Error(errUnexpected("k=" + k + " v=" + v))
  184. }
  185. rc.Del("list1", "list2")
  186. }
  187. // TestBRPop reproduces the example from http://redis.io/commands/brpop.
  188. func TestBRPop(t *testing.T) {
  189. rc.Del("list1", "list2")
  190. rc.RPush("list1", "a", "b", "c")
  191. if k, v, err := rc.BRPop(0, "list1", "list2"); err != nil {
  192. t.Error(err)
  193. } else if k != "list1" || v != "c" {
  194. t.Error(errUnexpected("k=" + k + " v=" + v))
  195. }
  196. rc.Del("list1", "list2")
  197. }
  198. // TestBRPopTimeout is the same as TestBRPop, but expects a time out.
  199. // TestBRPopTimeout also tests BLPop (because both share the same code).
  200. func TestBRPopTimeout(t *testing.T) {
  201. rc.Del("list1", "list2")
  202. if k, v, err := rc.BRPop(1, "list1", "list2"); err != ErrTimedOut {
  203. if err != nil {
  204. t.Error(err)
  205. } else {
  206. t.Error(errUnexpected("k=" + k + " v=" + v))
  207. }
  208. }
  209. rc.Del("list1", "list2")
  210. }
  211. // TestBRPopLPush takes last item of a list and inserts into another.
  212. func TestBRPopLPush(t *testing.T) {
  213. rc.Del("list1", "list2")
  214. rc.RPush("list1", "a", "b", "c")
  215. if v, err := rc.BRPopLPush("list1", "list2", 0); err != nil {
  216. t.Error(err)
  217. } else if v != "c" {
  218. t.Error(errUnexpected("v=" + v))
  219. }
  220. rc.Del("list1", "list2")
  221. }
  222. // TestBRPopLPushTimeout is the same as TestBRPopLPush, but expects a time out.
  223. func TestBRPopLPushTimeout(t *testing.T) {
  224. rc.Del("list1", "list2")
  225. if v, err := rc.BRPopLPush("list1", "list2", 1); err != ErrTimedOut {
  226. if err != nil {
  227. t.Error(err)
  228. } else {
  229. t.Error(errUnexpected("v=" + v))
  230. }
  231. }
  232. rc.Del("list1", "list2")
  233. }
  234. // TestClientListKill kills the first connection returned by CLIENT LIST.
  235. func TestClientListKill(t *testing.T) {
  236. var addr []string
  237. if clients, err := rc.ClientList(); err != nil {
  238. t.Error(err)
  239. return
  240. } else if len(clients) < 1 {
  241. t.Error(errUnexpected(clients))
  242. return
  243. } else {
  244. addr = strings.Split(clients[0], " ")
  245. }
  246. if err := rc.ClientKill(addr[0][5:]); err != nil {
  247. t.Error(err)
  248. }
  249. rc.ClientList() // send any cmd to enforce socket shutdown
  250. }
  251. // TestClientSetName name the current connection, and looks it up in the list.
  252. func TestClientSetName(t *testing.T) {
  253. if err := rc.ClientSetName("bozo"); err != nil {
  254. t.Error(err)
  255. return
  256. }
  257. if clients, err := rc.ClientList(); err != nil {
  258. t.Error(err)
  259. return
  260. } else if len(clients) < 1 {
  261. t.Error(errUnexpected(clients))
  262. return
  263. } else {
  264. found := false
  265. for _, info := range clients {
  266. if strings.Contains(info, " name=bozo ") {
  267. found = true
  268. break
  269. }
  270. }
  271. if !found {
  272. t.Error("Could not find client after SetName")
  273. }
  274. }
  275. }
  276. // TestConfigGet tests the server port number.
  277. func TestConfigGet(t *testing.T) {
  278. if items, err := rc.ConfigGet("*"); err != nil {
  279. t.Error(err)
  280. } else if _, ok := items["dbfilename"]; !ok {
  281. t.Error(errUnexpected(items))
  282. }
  283. }
  284. // TestConfigSet sets redis dir to /tmp, and back to the default.
  285. func TestConfigSet(t *testing.T) {
  286. items, err := rc.ConfigGet("dir")
  287. if err != nil {
  288. t.Error(err)
  289. return
  290. }
  291. if err = rc.ConfigSet("dir", "/tmp"); err != nil {
  292. t.Error(err)
  293. return
  294. }
  295. if err := rc.ConfigSet("dir", items["dir"]); err != nil {
  296. t.Error(err)
  297. }
  298. }
  299. // TestConfigResetStat resets redis statistics.
  300. func TestConfigResetStat(t *testing.T) {
  301. if err := rc.ConfigResetStat(); err != nil {
  302. t.Error(err)
  303. }
  304. }
  305. // TestDBSize checks the current database size, adds a key, and checks again.
  306. func TestDBSize(t *testing.T) {
  307. size, err := rc.DBSize()
  308. if err != nil {
  309. t.Error(errUnexpected(err))
  310. return
  311. }
  312. rc.Set("test-db-size", "zzz")
  313. if new_size, err := rc.DBSize(); err != nil {
  314. t.Error(errUnexpected(err))
  315. } else if new_size != size+1 {
  316. t.Error(errUnexpected(new_size))
  317. }
  318. rc.Del("test-db-size")
  319. }
  320. // TestDebugSegfault crashes redis and breaks everything else.
  321. func __TestDebugSegfault(t *testing.T) {
  322. if err := rc.DebugSegfault(); err != nil {
  323. t.Error(err)
  324. }
  325. }
  326. // TestDecr reproduces the example from http://redis.io/commands/decr.
  327. func TestDecr(t *testing.T) {
  328. rc.Del("mykey")
  329. rc.Set("mykey", "10")
  330. if n, err := rc.Decr("mykey"); err != nil {
  331. t.Error(errUnexpected(err))
  332. } else if n != 9 {
  333. t.Error(errUnexpected(n))
  334. }
  335. rc.Del("mykey")
  336. }
  337. // TestDecrBy reproduces the example from http://redis.io/commands/decrby.
  338. func TestDecrBy(t *testing.T) {
  339. rc.Del("mykey")
  340. rc.Set("mykey", "10")
  341. if n, err := rc.DecrBy("mykey", 5); err != nil {
  342. t.Error(errUnexpected(err))
  343. } else if n != 5 {
  344. t.Error(errUnexpected(n))
  345. }
  346. rc.Del("mykey")
  347. }
  348. // TestIncr reproduces the example from http://redis.io/commands/incr.
  349. func TestIncr(t *testing.T) {
  350. rc.Del("mykey")
  351. rc.Set("mykey", "0")
  352. if n, err := rc.Incr("mykey"); err != nil {
  353. t.Error(errUnexpected(err))
  354. } else if n != 1 {
  355. t.Error(errUnexpected(n))
  356. }
  357. rc.Del("mykey")
  358. }
  359. // TestIncrBy reproduces the example from http://redis.io/commands/incrby.
  360. func TestIncrBy(t *testing.T) {
  361. rc.Del("mykey")
  362. rc.Set("mykey", "0")
  363. if n, err := rc.IncrBy("mykey", 5); err != nil {
  364. t.Error(errUnexpected(err))
  365. } else if n != 5 {
  366. t.Error(errUnexpected(n))
  367. }
  368. rc.Del("mykey")
  369. }
  370. // TestDel creates 1024 keys and deletes them.
  371. func TestDel(t *testing.T) {
  372. keys := make([]string, 1024)
  373. for n := 0; n < cap(keys); n++ {
  374. k := randomString(4) + string(n)
  375. v := randomString(32)
  376. if err := rc.Set(k, v); err != nil {
  377. t.Error(err)
  378. break
  379. } else {
  380. keys[n] = k
  381. }
  382. }
  383. if deleted, err := rc.Del(keys...); err != nil {
  384. t.Error(err)
  385. } else if deleted != cap(keys) {
  386. t.Error(errUnexpected(deleted))
  387. }
  388. }
  389. // TODO: TestDiscard
  390. // TestDump reproduces the example from http://redis.io/commands/dump.
  391. func TestDump(t *testing.T) {
  392. rc.Set("mykey", "10")
  393. if v, err := rc.Dump("mykey"); err != nil {
  394. t.Error(err)
  395. } else if v != "\u0000\xC0\n\u0006\u0000\xF8r?\xC5\xFB\xFB_(" {
  396. t.Error(errUnexpected(v))
  397. }
  398. rc.Del("mykey")
  399. }
  400. // TestDump reproduces the example from http://redis.io/commands/echo.
  401. func TestEcho(t *testing.T) {
  402. m := "Hello World!"
  403. if v, err := rc.Echo(m); err != nil {
  404. t.Error(err)
  405. } else if v != m {
  406. t.Error(errUnexpected(v))
  407. }
  408. }
  409. // TestEval tests server side Lua script.
  410. // TODO: fix the response.
  411. func TestEval(t *testing.T) {
  412. if _, err := rc.Eval(
  413. "return {1,{2,3,'foo'},KEYS[1],KEYS[2],ARGV[1],ARGV[2]}",
  414. 2, // numkeys
  415. []string{"key1", "key2"}, // keys
  416. []string{"first", "second"}, // args
  417. ); err != nil {
  418. t.Error(err)
  419. }
  420. //fmt.Printf("v=%#v\n", v)
  421. }
  422. // TestEvalSha tests server side Lua script.
  423. // TestEvalSha preloads the script with ScriptLoad.
  424. // TODO: fix the response.
  425. func TestEvalSha(t *testing.T) {
  426. sha1, err := rc.ScriptLoad("return {1,{2,3,'foo'},KEYS[1],KEYS[2],ARGV[1],ARGV[2]}")
  427. if err != nil {
  428. t.Error(err)
  429. return
  430. }
  431. if _, err = rc.EvalSha(
  432. sha1, // pre-loaded script
  433. 2, // numkeys
  434. []string{"key1", "key2"}, // keys
  435. []string{"first", "second"}, // args
  436. ); err != nil {
  437. t.Error(err)
  438. }
  439. //fmt.Printf("v=%#v\n", v)
  440. }
  441. // TODO: TestExec
  442. // TestExists reproduces the example from http://redis.io/commands/exists.
  443. func TestExists(t *testing.T) {
  444. rc.Del("key1", "key2")
  445. rc.Set("key1", "Hello")
  446. if ok, err := rc.Exists("key1"); err != nil {
  447. t.Error(err)
  448. return
  449. } else if !ok {
  450. t.Error(errUnexpected(ok))
  451. return
  452. }
  453. if ok, err := rc.Exists("key2"); err != nil {
  454. t.Error(err)
  455. return
  456. } else if ok {
  457. t.Error(errUnexpected(ok))
  458. return
  459. }
  460. }
  461. // TestExpire reproduces the example from http://redis.io/commands/expire.
  462. // TestExpire also tests the TTL command.
  463. func TestExpire(t *testing.T) {
  464. defer func() { rc.Del("mykey") }()
  465. rc.Set("mykey", "hello")
  466. if ok, err := rc.Expire("mykey", 10); err != nil {
  467. t.Error(err)
  468. return
  469. } else if !ok {
  470. t.Error(errUnexpected(ok))
  471. return
  472. }
  473. if ttl, err := rc.TTL("mykey"); err != nil {
  474. t.Error(err)
  475. return
  476. } else if ttl != 10 {
  477. t.Error(errUnexpected(ttl))
  478. return
  479. }
  480. rc.Set("mykey", "Hello World")
  481. if ttl, err := rc.TTL("mykey"); err != nil {
  482. t.Error(err)
  483. } else if ttl != -1 {
  484. t.Error(errUnexpected(ttl))
  485. }
  486. }
  487. // TestExpireAt reproduces the example from http://redis.io/commands/expire.
  488. func TestExpireAt(t *testing.T) {
  489. defer func() { rc.Del("mykey") }()
  490. rc.Set("mykey", "hello")
  491. if ok, err := rc.Exists("mykey"); err != nil {
  492. t.Error(err)
  493. return
  494. } else if !ok {
  495. t.Error(errUnexpected(ok))
  496. return
  497. }
  498. if ok, err := rc.ExpireAt("mykey", 1293840000); err != nil {
  499. t.Error(err)
  500. return
  501. } else if !ok {
  502. t.Error(errUnexpected(ok))
  503. return
  504. }
  505. if ok, err := rc.Exists("mykey"); err != nil {
  506. t.Error(err)
  507. } else if ok {
  508. t.Error(errUnexpected(ok))
  509. }
  510. }
  511. // FlushAll and FlushDB are not required because they never fail.
  512. // TestGet reproduces the example from http://redis.io/commands/get
  513. func TestGet(t *testing.T) {
  514. rc.Del("nonexisting")
  515. if v, err := rc.Get("nonexisting"); err != nil {
  516. t.Error(err)
  517. return
  518. } else if v != "" {
  519. t.Error(errUnexpected(v))
  520. return
  521. }
  522. rc.Set("mykey", "Hello")
  523. if v, err := rc.Get("mykey"); err != nil {
  524. t.Error(err)
  525. } else if v == "" {
  526. t.Error(errUnexpected(v))
  527. }
  528. rc.Del("mykey")
  529. }
  530. // TestGetBit reproduces the example from http://redis.io/commands/getbit.
  531. // TestGetBit also tests SetBit.
  532. func TestGetBit(t *testing.T) {
  533. defer func() { rc.Del("mykey") }()
  534. if _, err := rc.SetBit("mykey", 7, 1); err != nil {
  535. t.Error(err)
  536. return
  537. }
  538. if v, err := rc.GetBit("mykey", 0); err != nil {
  539. t.Error(err)
  540. return
  541. } else if v != 0 {
  542. t.Error(errUnexpected(v))
  543. return
  544. }
  545. if v, err := rc.GetBit("mykey", 7); err != nil {
  546. t.Error(err)
  547. } else if v != 1 {
  548. t.Error(errUnexpected(v))
  549. }
  550. }
  551. // TestGetRange reproduces the example from http://redis.io/commands/getrange.
  552. func TestGetRange(t *testing.T) {
  553. defer func() { rc.Del("mykey") }()
  554. rc.Set("mykey", "This is a string")
  555. if v, err := rc.GetRange("mykey", 0, 3); err != nil {
  556. t.Error(err)
  557. return
  558. } else if v != "This" {
  559. t.Error(errUnexpected(v))
  560. return
  561. }
  562. if v, err := rc.GetRange("mykey", -3, -1); err != nil {
  563. t.Error(err)
  564. return
  565. } else if v != "ing" {
  566. t.Error(errUnexpected(v))
  567. return
  568. }
  569. if v, err := rc.GetRange("mykey", 0, -1); err != nil {
  570. t.Error(err)
  571. return
  572. } else if v != "This is a string" {
  573. t.Error(errUnexpected(v))
  574. return
  575. }
  576. if v, err := rc.GetRange("mykey", 10, 100); err != nil {
  577. t.Error(err)
  578. } else if v != "string" {
  579. t.Error(errUnexpected(v))
  580. }
  581. }
  582. // TestGetSet reproduces the example from http://redis.io/commands/getset.
  583. func TestGetSet(t *testing.T) {
  584. rc.Del("mycounter")
  585. rc.Incr("mycounter")
  586. if v, err := rc.GetSet("mycounter", "0"); err != nil {
  587. t.Error(err)
  588. return
  589. } else if v != "1" {
  590. t.Error(errUnexpected(v))
  591. return
  592. }
  593. if v, err := rc.Get("mycounter"); err != nil {
  594. t.Error(err)
  595. } else if v != "0" {
  596. t.Error(errUnexpected(v))
  597. }
  598. rc.Del("mycounter")
  599. }
  600. // TestMGet reproduces the example from http://redis.io/commands/mget.
  601. func TestMGet(t *testing.T) {
  602. rc.Set("key1", "Hello")
  603. rc.Set("key2", "World")
  604. if items, err := rc.MGet("key1", "key2"); err != nil {
  605. t.Error(err)
  606. } else if items[0] != "Hello" || items[1] != "World" {
  607. t.Error(errUnexpected(items))
  608. }
  609. rc.Del("key1", "key2")
  610. }
  611. // TestMSet reproduces the example from http://redis.io/commands/mset.
  612. func TestMSet(t *testing.T) {
  613. rc.Del("key1", "key2")
  614. if err := rc.MSet(map[string]string{
  615. "key1": "Hello", "key2": "World",
  616. }); err != nil {
  617. t.Error(err)
  618. return
  619. }
  620. v1, _ := rc.Get("key1")
  621. v2, _ := rc.Get("key2")
  622. if v1 != "Hello" || v2 != "World" {
  623. t.Error(errUnexpected(v1 + ", " + v2))
  624. }
  625. rc.Del("key1", "key2")
  626. }
  627. // TestKeys reproduces the example from http://redis.io/commands/keys
  628. func TestKeys(t *testing.T) {
  629. rc.MSet(map[string]string{
  630. "one": "1", "two": "2", "three": "3", "four": "4",
  631. })
  632. defer func() { rc.Del("one", "two", "three", "four") }()
  633. keys, err := rc.Keys("*o*")
  634. if err != nil {
  635. t.Error(err)
  636. return
  637. }
  638. c := 0
  639. for _, k := range keys {
  640. switch k {
  641. case "one", "two", "four":
  642. c++
  643. }
  644. }
  645. if c != 3 {
  646. t.Error(errUnexpected(keys))
  647. }
  648. }
  649. func TestSAdd(t *testing.T) {
  650. k := randomString(1024)
  651. //singles
  652. for i := 0; i < 10; i++ {
  653. v := randomString(32)
  654. _, err := rc.SAdd(k, v)
  655. if err != nil {
  656. t.Error(err)
  657. return
  658. }
  659. }
  660. //multiple
  661. _, err := rc.SAdd(k, "setuno", "setdue")
  662. if err != nil {
  663. t.Error(err)
  664. }
  665. }
  666. func TestSMembers(t *testing.T) {
  667. k := randomString(1024)
  668. rc.SAdd(k, "setuno", "setdue")
  669. members, err := rc.SMembers(k)
  670. if err != nil {
  671. t.Error(err)
  672. return
  673. }
  674. if len(members) != 2 {
  675. t.Error("Invalid member count ", len(members))
  676. return
  677. }
  678. }
  679. // TestSetAndGet sets a key, fetches it, and compare the results.
  680. func _TestSetAndGet(t *testing.T) {
  681. k := randomString(1024)
  682. v := randomString(16 * 1024 * 1024)
  683. if err := rc.Set(k, v); err != nil {
  684. t.Error(err)
  685. return
  686. }
  687. if val, err := rc.Get(k); err != nil {
  688. t.Error(err)
  689. return
  690. } else if val != v {
  691. t.Error(errUnexpected(val))
  692. }
  693. // try to clean up anyway
  694. rc.Del(k)
  695. }
  696. // TestSetEx sets a key to expire in 10s and checks the result.
  697. func TestSetEx(t *testing.T) {
  698. k := randomString(16)
  699. if err := rc.SetEx(k, 10, "foobar"); err != nil {
  700. t.Error(err)
  701. return
  702. }
  703. rc.Del(k)
  704. }
  705. func TestPing(t *testing.T) {
  706. if err := rc.Ping(); err != nil {
  707. t.Error(err)
  708. return
  709. }
  710. }
  711. // TestHIncrBy
  712. func TestHIncrBy(t *testing.T) {
  713. rc.Del("mykey")
  714. if n, err := rc.HIncrBy("mykey", "beavis", 5); err != nil {
  715. t.Error(errUnexpected(err))
  716. } else if n != 5 {
  717. t.Error(errUnexpected(n))
  718. }
  719. rc.Del("mykey")
  720. }
  721. // TestHGet
  722. func TestHGet(t *testing.T) {
  723. rc.Del("mykey")
  724. if _, err := rc.HIncrBy("mykey", "beavis", 5); err != nil {
  725. t.Error(errUnexpected(err))
  726. }
  727. if n, err := rc.HGet("mykey", "beavis"); err != nil {
  728. t.Error(errUnexpected(err))
  729. } else if n != "5" {
  730. t.Error(errUnexpected(n))
  731. }
  732. rc.Del("mykey")
  733. }
  734. // TestZIncrBy
  735. func TestZIncrBy(t *testing.T) {
  736. rc.Del("mykey")
  737. if n, err := rc.ZIncrBy("mykey", 5, "beavis"); err != nil {
  738. t.Error(errUnexpected(err))
  739. } else if n != "5" {
  740. t.Error(errUnexpected(n))
  741. }
  742. rc.Del("mykey")
  743. }
  744. // TestZScore
  745. func TestZScore(t *testing.T) {
  746. rc.Del("mykey")
  747. if _, err := rc.ZIncrBy("mykey", 5, "beavis"); err != nil {
  748. t.Error(errUnexpected(err))
  749. }
  750. if n, err := rc.ZScore("mykey", "beavis"); err != nil {
  751. t.Error(errUnexpected(err))
  752. } else if n != "5" {
  753. t.Error(errUnexpected(n))
  754. }
  755. rc.Del("mykey")
  756. }
  757. // Test ZAdd
  758. func TestZAdd(t *testing.T) {
  759. rc.Del("myzset")
  760. if _, err := rc.ZAdd("myzset", 1, "beavis"); err != nil {
  761. t.Error(errUnexpected(err))
  762. }
  763. if n, err := rc.ZAdd("myzset", 2, "butthead", 3, "professor_buzzcut"); err != nil {
  764. t.Error(errUnexpected(err))
  765. } else if n != 2 {
  766. t.Error(errUnexpected(n))
  767. }
  768. rc.Del("myzset")
  769. }
  770. // Test ZRem
  771. func TestZRem(t *testing.T) {
  772. rc.Del("myzset")
  773. if _, err := rc.ZAdd("myzset", 1, "beavis", 2, "butthead", 3, "professor_buzzcut"); err != nil {
  774. t.Error(errUnexpected(err))
  775. }
  776. if n, err := rc.ZRem("myzset", "beavis", "butthead", "professor_buzzcut"); err != nil {
  777. t.Error(errUnexpected(err))
  778. } else if n != 3 {
  779. t.Error(errUnexpected(n))
  780. }
  781. rc.Del("myzset")
  782. }
  783. // Test ZRange
  784. func TestZRange(t *testing.T) {
  785. rc.Del("myzset")
  786. if _, err := rc.ZAdd("myzset", 1, "beavis", 2, "butthead", 3, "professor_buzzcut"); err != nil {
  787. t.Error(errUnexpected(err))
  788. }
  789. if n, err := rc.ZRange("myzset", 0, 1, false); err != nil {
  790. t.Error(errUnexpected(err))
  791. } else if len(n) != 2 {
  792. t.Error(errUnexpected(n))
  793. }
  794. if n, err := rc.ZRange("myzset", 0, 1, true); err != nil {
  795. t.Error(errUnexpected(err))
  796. } else if len(n) != 4 {
  797. t.Error(errUnexpected(n))
  798. } else if n[0] != "beavis" && n[2] != "butthead" {
  799. t.Error(errUnexpected(n))
  800. }
  801. rc.Del("myzset")
  802. }
  803. // Test ZCard
  804. func TestZCard(t *testing.T) {
  805. rc.Del("myzset")
  806. if _, err := rc.ZAdd("myzset", 1, "beavis", 2, "butthead", 3, "professor_buzzcut"); err != nil {
  807. t.Error(errUnexpected(err))
  808. }
  809. if n, err := rc.ZCard("myzset"); err != nil {
  810. t.Error(errUnexpected(err))
  811. } else if n != 3 {
  812. t.Error(errUnexpected(n))
  813. }
  814. rc.Del("myzset")
  815. }
  816. // Test ZCount
  817. func TestZCount(t *testing.T) {
  818. rc.Del("myzset")
  819. if _, err := rc.ZAdd("myzset", 1, "beavis", 2, "butthead", 3, "professor_buzzcut"); err != nil {
  820. t.Error(errUnexpected(err))
  821. }
  822. if n, err := rc.ZCount("myzset", 0, 2); err != nil {
  823. t.Error(errUnexpected(err))
  824. } else if n != 2 {
  825. t.Error(errUnexpected(n))
  826. }
  827. rc.Del("myzset")
  828. }
  829. // Benchmark plain Set
  830. func BenchmarkSet(b *testing.B) {
  831. for i := 0; i < b.N; i++ {
  832. if err := rc.Set("foo", "bar"); err != nil {
  833. b.Error(err)
  834. return
  835. }
  836. }
  837. }
  838. // Benchmark plain Get
  839. func BenchmarkGet(b *testing.B) {
  840. rc.Set("foo", "bar")
  841. for i := 0; i < b.N; i++ {
  842. if v, err := rc.Get("foo"); err != nil {
  843. b.Error(err)
  844. break
  845. } else if v != "bar" {
  846. b.Error(errUnexpected(v))
  847. break
  848. }
  849. }
  850. rc.Del("foo")
  851. }
  852. // Test/Benchmark INCRBY
  853. func BenchmarkIncrBy(b *testing.B) {
  854. if err := rc.Set("foo", "0"); err != nil {
  855. b.Error(err)
  856. return
  857. }
  858. defer func() { rc.Del("foo") }()
  859. for i := 0; i < b.N; i++ {
  860. if _, err := rc.IncrBy("foo", 1); err != nil {
  861. b.Error(err)
  862. return
  863. }
  864. }
  865. if v, err := rc.Get("foo"); err != nil {
  866. b.Error(err)
  867. } else if v != strconv.Itoa(b.N) {
  868. b.Error("wrong incr result")
  869. }
  870. }
  871. // Benchmark DECR
  872. func BenchmarkDecrBy(b *testing.B) {
  873. if err := rc.Set("foo", strconv.Itoa(b.N)); err != nil {
  874. b.Error(err)
  875. return
  876. }
  877. defer func() { rc.Del("foo") }()
  878. for i := 0; i < b.N; i++ {
  879. if _, err := rc.DecrBy("foo", 1); err != nil {
  880. b.Error(err)
  881. return
  882. }
  883. }
  884. if v, err := rc.Get("foo"); err != nil {
  885. b.Error(err)
  886. } else if v != "0" {
  887. b.Error("wrong decr result")
  888. }
  889. }