list_test failing because redis server timeout (idk why)

Author: robinbraemer

client.go

@@ -34,6 +34,15 @@ func (r *Redis) NewClient(conn redcon.Conn) *Client {
 	return c
 }
 
+// NextClientId atomically gets and increments a counter to return the next client id.
+func (r *Redis) NextClientId() ClientId {
+	r.Mu().Lock()
+	defer r.Mu().Unlock()
+	id := r.nextClientId
+	r.nextClientId++
+	return id
+}
+
 // Clients gets the current connected clients.
 func (r *Redis) Clients() Clients {
 	r.Mu().RLock()

cmd_lpush.go

@@ -12,12 +12,13 @@ func LPushCommand(c *Client, cmd redcon.Command) {
 		return
 	}
 	key := string(cmd.Args[1])
-
+	fmt.Println("KEY:", key)
 	db := c.Db()
 	i := db.GetOrExpire(&key, true)
 	if i == nil {
 		i = NewList()
 		db.Set(&key, i, false, time.Time{})
+		fmt.Println("CREATED NEW LIST")
 	} else if i.Type() != ListType {
 		c.Conn().WriteError(fmt.Sprintf("%s: key is a %s not a %s", WrongTypeErr, i.TypeFancy(), ListTypeFancy))
 		return

cmd_set.go

@@ -8,6 +8,7 @@ import (
 	"time"
 )
 
+// SET key value [NX] [XX] [EX <seconds>] [PX <milliseconds>]
 func SetCommand(c *Client, cmd redcon.Command) {
 	if len(cmd.Args) == 1 { // nothing done
 		c.Conn().WriteString("OK")

list_test.go

@@ -0,0 +1,64 @@
+package redis
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestLPushCommand(t *testing.T) {
+	i, err := c.LPush("lpushkey", "va").Result()
+	assert.NoError(t, err)
+	assert.Equal(t, int64(1), i)
+
+	i, err = c.LPush("lpushkey", "vb").Result()
+	assert.NoError(t, err)
+	assert.Equal(t, int64(2), i)
+
+	i, err = c.LPush("lpushkey", "vc", "vd").Result()
+	assert.NoError(t, err)
+	assert.Equal(t, int64(4), i)
+
+	i, err = c.LPush("lpushkey2", "1", "2").Result()
+	assert.NoError(t, err)
+	assert.Equal(t, int64(2), i)
+
+	i, err = c.LPush("lpush3key").Result()
+	assert.Error(t, err)
+}
+
+func TestLPopCommand(t *testing.T) {
+	s, err := c.LPop("lpop1").Result()
+	assert.Zero(t, s)
+	assert.Error(t, err)
+
+	i, err := c.LPush("list", "a", "b").Result()
+	assert.NoError(t, err)
+	assert.Equal(t, int64(2), i)
+
+	s, err = c.LPop("list").Result()
+	assert.NoError(t, err)
+	assert.Equal(t, "b", s)
+
+	s, err = c.LPop("list").Result()
+	assert.NoError(t, err)
+	assert.Equal(t, "a", s)
+
+	s, err = c.LPop("list").Result()
+	assert.Error(t, err)
+	assert.Zero(t, s)
+}
+
+func TestLRangeCommand(t *testing.T) {
+	s, err := c.LRange("lrange", 0, 0).Result()
+	assert.Error(t, err)
+	assert.Zero(t, s)
+
+	sl, err := c.Set("works", "esfkjsefj", 0).Result()
+	assert.NoError(t, err)
+	assert.NotZero(t, sl)
+	assert.NotEmpty(t, sl)
+
+	i, err := c.LPush("list2", "a", "b").Result()
+	assert.NoError(t, err)
+	assert.Equal(t, int64(2), i)
+}

redis.go

@@ -1,11 +1,9 @@
 package redis
 
 import (
-	"crypto/tls"
 	"github.com/redis-go/redcon"
 	"strings"
 	"sync"
-	"time"
 )
 
 const (
@@ -62,47 +60,6 @@ type Clients map[ClientId]*Client
 // Client id
 type ClientId uint64
 
-// Run runs the default redis server.
-// Initializes the default redis if not already.
-func Run(addr string) error {
-	return Default().Run(addr)
-}
-
-// Run runs the redis server.
-func (r *Redis) Run(addr string) error {
-	go r.KeyExpirer().Start(100*time.Millisecond, 20, 25)
-	return redcon.ListenAndServe(
-		addr,
-		func(conn redcon.Conn, cmd redcon.Command) {
-			r.HandlerFn()(r.NewClient(conn), cmd)
-		},
-		func(conn redcon.Conn) bool {
-			return r.AcceptFn()(r.NewClient(conn))
-		},
-		func(conn redcon.Conn, err error) {
-			r.OnCloseFn()(r.NewClient(conn), err)
-		},
-	)
-}
-
-// Run runs the redis server with tls.
-func (r *Redis) RunTLS(addr string, tls *tls.Config) error {
-	go r.KeyExpirer().Start(100*time.Millisecond, 20, 25)
-	return redcon.ListenAndServeTLS(
-		addr,
-		func(conn redcon.Conn, cmd redcon.Command) {
-			r.HandlerFn()(r.NewClient(conn), cmd)
-		},
-		func(conn redcon.Conn) bool {
-			return r.AcceptFn()(r.NewClient(conn))
-		},
-		func(conn redcon.Conn, err error) {
-			r.OnCloseFn()(r.NewClient(conn), err)
-		},
-		tls,
-	)
-}
-
 // Gets the handler func.
 func (r *Redis) HandlerFn() Handler {
 	r.Mu().RLock()
@@ -153,15 +110,6 @@ func (r *Redis) Mu() *sync.RWMutex {
 	return r.mu
 }
 
-// NextClientId atomically gets and increments a counter to return the next client id.
-func (r *Redis) NextClientId() ClientId {
-	r.Mu().Lock()
-	defer r.Mu().Unlock()
-	id := r.nextClientId
-	r.nextClientId++
-	return id
-}
-
 func (r *Redis) KeyExpirer() KeyExpirer {
 	r.Mu().RLock()
 	defer r.Mu().RUnlock()

redis_test.go

@@ -78,71 +78,18 @@ func TestTtlCommand(t *testing.T) {
 	assert.NoError(t, err)
 
 	ttl, err = c.TTL("bKey").Result()
-	assert.Equal(t, time.Duration(-1000000000), ttl)
 	assert.NoError(t, err)
+	assert.Equal(t, time.Duration(-1000000000), ttl)
 }
 
 func TestExpiry(t *testing.T) {
 	s, err := c.Set("x", "val", 10*time.Millisecond).Result()
-	assert.Equal(t, "OK", s)
 	assert.NoError(t, err)
+	assert.Equal(t, "OK", s)
 
 	time.Sleep(10 * time.Millisecond)
 
 	s, err = c.Get("x").Result()
 	assert.Equal(t, "", s)
 	assert.Error(t, err)
 }
-
-func TestLPushCommand(t *testing.T) {
-	i, err := c.LPush("lpushkey", "va").Result()
-	assert.Equal(t, int64(1), i)
-	assert.NoError(t, err)
-
-	i, err = c.LPush("lpushkey", "vb").Result()
-	assert.Equal(t, int64(2), i)
-	assert.NoError(t, err)
-
-	i, err = c.LPush("lpushkey", "vc", "vd").Result()
-	assert.Equal(t, int64(4), i)
-	assert.NoError(t, err)
-
-	i, err = c.LPush("lpushkey2", "1", "2").Result()
-	assert.Equal(t, int64(2), i)
-	assert.NoError(t, err)
-
-	i, err = c.LPush("lpush3key").Result()
-	assert.Error(t, err)
-}
-
-func TestLPopCommand(t *testing.T) {
-	s, err := c.LPop("lpop1").Result()
-	assert.Zero(t, s)
-	assert.Error(t, err)
-
-	i, err := c.LPush("list", "a", "b").Result()
-	assert.Equal(t, int64(2), i)
-	assert.NoError(t, err)
-
-	s, err = c.LPop("list").Result()
-	assert.Equal(t, "b", s)
-	assert.NoError(t, err)
-
-	s, err = c.LPop("list").Result()
-	assert.Equal(t, "a", s)
-	assert.NoError(t, err)
-
-	s, err = c.LPop("list").Result()
-	assert.Zero(t, s)
-	assert.Error(t, err)
-}
-
-func TestLRangeCommand(t *testing.T) {
-	s, err := c.LRange("lrange", 0, 0).Result()
-	assert.Zero(t, s)
-	assert.Error(t, err)
-
-	i, err := c.LPush("list2", "a", "b").Result()
-	assert.Equal(t, int64(2), i)
-	assert.NoError(t, err)
-}

serve.go

@@ -0,0 +1,48 @@
+package redis
+
+import (
+	"crypto/tls"
+	"github.com/redis-go/redcon"
+	"time"
+)
+
+// Run runs the default redis server.
+// Initializes the default redis if not already.
+func Run(addr string) error {
+	return Default().Run(addr)
+}
+
+// Run runs the redis server.
+func (r *Redis) Run(addr string) error {
+	go r.KeyExpirer().Start(100*time.Millisecond, 20, 25)
+	return redcon.ListenAndServe(
+		addr,
+		func(conn redcon.Conn, cmd redcon.Command) {
+			r.HandlerFn()(r.NewClient(conn), cmd)
+		},
+		func(conn redcon.Conn) bool {
+			return r.AcceptFn()(r.NewClient(conn))
+		},
+		func(conn redcon.Conn, err error) {
+			r.OnCloseFn()(r.NewClient(conn), err)
+		},
+	)
+}
+
+// Run runs the redis server with tls.
+func (r *Redis) RunTLS(addr string, tls *tls.Config) error {
+	go r.KeyExpirer().Start(100*time.Millisecond, 20, 25)
+	return redcon.ListenAndServeTLS(
+		addr,
+		func(conn redcon.Conn, cmd redcon.Command) {
+			r.HandlerFn()(r.NewClient(conn), cmd)
+		},
+		func(conn redcon.Conn) bool {
+			return r.AcceptFn()(r.NewClient(conn))
+		},
+		func(conn redcon.Conn, err error) {
+			r.OnCloseFn()(r.NewClient(conn), err)
+		},
+		tls,
+	)
+}