simple support for DUMP and RESTORE

Author: alyssaruth

README.md

@@ -36,6 +36,7 @@ Implemented commands:
  - Key
    - COPY
    - DEL
+   - DUMP -- partly, only handles string keys
    - EXISTS
    - EXPIRE
    - EXPIREAT
@@ -50,6 +51,7 @@ Implemented commands:
    - RANDOMKEY -- see m.Seed(...)
    - RENAME
    - RENAMENX
+   - RESTORE -- partly, only handles string keys
    - SCAN
    - TOUCH
    - TTL
@@ -301,10 +303,8 @@ Commands which will probably not be implemented:
     - ~~READONLY~~
     - ~~READWRITE~~
  - Key
-    - ~~DUMP~~
     - ~~MIGRATE~~
     - ~~OBJECT~~
-    - ~~RESTORE~~
     - ~~WAIT~~
  - Scripting
     - ~~FCALL / FCALL_RO *~~

cmd_generic.go

@@ -32,7 +32,7 @@ func inMilliSeconds(t time.Time) int {
 func commandsGeneric(m *Miniredis) {
 	m.srv.Register("COPY", m.cmdCopy)
 	m.srv.Register("DEL", m.cmdDel)
-	// DUMP
+	m.srv.Register("DUMP", m.cmdDump)
 	m.srv.Register("EXISTS", m.cmdExists)
 	m.srv.Register("EXPIRE", makeCmdExpire(m, false, time.Second))
 	m.srv.Register("EXPIREAT", makeCmdExpire(m, true, time.Second))
@@ -49,7 +49,7 @@ func commandsGeneric(m *Miniredis) {
 	m.srv.Register("RANDOMKEY", m.cmdRandomkey)
 	m.srv.Register("RENAME", m.cmdRename)
 	m.srv.Register("RENAMENX", m.cmdRenamenx)
-	// RESTORE
+	m.srv.Register("RESTORE", m.cmdRestore)
 	m.srv.Register("TOUCH", m.cmdTouch)
 	m.srv.Register("TTL", m.cmdTTL)
 	m.srv.Register("TYPE", m.cmdType)
@@ -315,6 +315,27 @@ func (m *Miniredis) cmdDel(c *server.Peer, cmd string, args []string) {
 	})
 }
 
+// DUMP
+func (m *Miniredis) cmdDump(c *server.Peer, cmd string, args []string) {
+	if !m.isValidCMD(c, cmd, args, exactly(1)) {
+		return
+	}
+
+	key := args[0]
+
+	withTx(m, c, func(c *server.Peer, ctx *connCtx) {
+		db := m.db(ctx.selectedDB)
+		keyType, exists := db.keys[key]
+		if !exists {
+			c.WriteNull()
+		} else if keyType != keyTypeString {
+			c.WriteError(msgWrongType)
+		} else {
+			c.WriteBulk(db.stringGet(key))
+		}
+	})
+}
+
 // TYPE
 func (m *Miniredis) cmdType(c *server.Peer, cmd string, args []string) {
 	if !m.isValidCMD(c, cmd, args, exactly(1)) {
@@ -487,6 +508,78 @@ func (m *Miniredis) cmdRenamenx(c *server.Peer, cmd string, args []string) {
 	})
 }
 
+type restoreOpts struct {
+	key             string
+	serializedValue string
+	rawTtl          string
+	replace         bool
+	absTtl          bool
+}
+
+func restoreParse(args []string) *restoreOpts {
+	var opts restoreOpts
+
+	opts.key, opts.rawTtl, opts.serializedValue, args = args[0], args[1], args[2], args[3:]
+
+	for len(args) > 0 {
+		switch arg := strings.ToUpper(args[0]); arg {
+		case "REPLACE":
+			opts.replace = true
+		case "ABSTTL":
+			opts.absTtl = true
+		default:
+			return nil
+		}
+
+		args = args[1:]
+	}
+
+	return &opts
+}
+
+// RESTORE
+func (m *Miniredis) cmdRestore(c *server.Peer, cmd string, args []string) {
+	if !m.isValidCMD(c, cmd, args, atLeast(3)) {
+		return
+	}
+
+	var opts = restoreParse(args)
+	if opts == nil {
+		setDirty(c)
+		c.WriteError(msgSyntaxError)
+		return
+	}
+
+	withTx(m, c, func(c *server.Peer, ctx *connCtx) {
+		db := m.db(ctx.selectedDB)
+
+		_, keyExists := db.keys[opts.key]
+		if keyExists && !opts.replace {
+			setDirty(c)
+			c.WriteError("BUSYKEY Target key name already exists.")
+			return
+		}
+
+		ttl, err := strconv.Atoi(opts.rawTtl)
+		if err != nil || ttl < 0 {
+			c.WriteError(msgInvalidInt)
+			return
+		}
+
+		db.stringSet(opts.key, opts.serializedValue)
+
+		if ttl != 0 {
+			if opts.absTtl {
+				db.ttl[opts.key] = m.at(ttl, time.Millisecond)
+			} else {
+				db.ttl[opts.key] = time.Duration(ttl) * time.Millisecond
+			}
+		}
+
+		c.WriteOK()
+	})
+}
+
 type scanOpts struct {
 	cursor    int
 	count     int

cmd_generic_test.go

@@ -287,6 +287,39 @@ func TestUnlink(t *testing.T) {
 	})
 }
 
+func TestDump(t *testing.T) {
+	s, c := runWithClient(t)
+	s.Set("existing-key", "value")
+	s.HSet("set-key", "a", "b")
+
+	t.Run("parse errors", func(t *testing.T) {
+		mustDo(t, c,
+			"DUMP",
+			proto.Error(errWrongNumber("dump")))
+
+		mustDo(t, c,
+			"DUMP", "key", "extra",
+			proto.Error(errWrongNumber("dump")))
+	})
+
+	t.Run("dump missing key", func(t *testing.T) {
+		mustNil(t, c,
+			"DUMP", "missing-key")
+	})
+
+	t.Run("dump existing key", func(t *testing.T) {
+		mustDo(t, c,
+			"DUMP", "existing-key",
+			proto.String("value"))
+	})
+
+	t.Run("dump wrong key type", func(t *testing.T) {
+		mustDo(t, c,
+			"DUMP", "set-key",
+			proto.Error(msgWrongType))
+	})
+}
+
 func TestType(t *testing.T) {
 	s, c := runWithClient(t)
 
@@ -316,11 +349,11 @@ func TestType(t *testing.T) {
 	t.Run("errors", func(t *testing.T) {
 		mustDo(t, c,
 			"TYPE",
-			proto.Error("usage error"),
+			proto.Error(errWrongNumber("type")),
 		)
 		mustDo(t, c,
 			"TYPE", "spurious", "arguments",
-			proto.Error("usage error"),
+			proto.Error(errWrongNumber("type")),
 		)
 	})
 
@@ -606,6 +639,67 @@ func TestRename(t *testing.T) {
 	})
 }
 
+func TestRestore(t *testing.T) {
+	s, c := runWithClient(t)
+	s.Set("existing-key", "value")
+
+	t.Run("busy key error", func(t *testing.T) {
+		mustDo(t, c,
+			"RESTORE", "existing-key", "0", "other-value",
+			proto.Error("BUSYKEY Target key name already exists."))
+
+		// Value hasn't changed
+		s.CheckGet(t, "existing-key", "value")
+	})
+
+	t.Run("overwrite existing key", func(t *testing.T) {
+		mustOK(t, c,
+			"RESTORE", "existing-key", "0", "new-value", "REPLACE")
+
+		s.CheckGet(t, "existing-key", "new-value")
+	})
+
+	t.Run("restore new key with no ttl", func(t *testing.T) {
+		mustOK(t, c, "RESTORE", "key-a", "0", "value-a")
+
+		s.CheckGet(t, "key-a", "value-a")
+		equals(t, time.Duration(0), s.TTL("key-a"))
+	})
+
+	t.Run("restore new key with regular ttl", func(t *testing.T) {
+		mustOK(t, c, "RESTORE", "key-b", "50", "value-b")
+
+		s.CheckGet(t, "key-b", "value-b")
+		equals(t, 50*time.Millisecond, s.TTL("key-b"))
+	})
+
+	t.Run("restore new key with absolute ttl", func(t *testing.T) {
+		s.SetTime(time.UnixMilli(1234567890))
+		mustOK(t, c, "RESTORE", "key-c", "1234577890", "value-c", "ABSTTL")
+
+		s.CheckGet(t, "key-c", "value-c")
+		equals(t, 10000*time.Millisecond, s.TTL("key-c"))
+	})
+
+	t.Run("parse errors", func(t *testing.T) {
+		mustDo(t, c,
+			"RESTORE",
+			proto.Error(errWrongNumber("restore")))
+
+		mustDo(t, c,
+			"RESTORE", "key", "-1", "serialized-value", "BADARG",
+			proto.Error(msgSyntaxError))
+
+		mustDo(t, c,
+			"RESTORE", "key", "-1", "serialized-value",
+			proto.Error(msgInvalidInt))
+
+		mustDo(t, c,
+			"RESTORE", "key", "argh", "serialized-value",
+			proto.Error(msgInvalidInt))
+	})
+}
+
 func TestScan(t *testing.T) {
 	s, c := runWithClient(t)
 

miniredis.go

@@ -373,15 +373,15 @@ func (m *Miniredis) Server() *server.Server {
 	return m.srv
 }
 
-// Dump returns a text version of the selected DB, usable for debugging.
+// DebugDump returns a text version of the selected DB, usable for debugging.
 //
-// Dump limits the maximum length of each key:value to "DumpMaxLineLen" characters.
+// DebugDump limits the maximum length of each key:value to "DumpMaxLineLen" characters.
 // To increase that, call something like:
 //
 //	miniredis.DumpMaxLineLen = 1024
 //	mr, _ = miniredis.Run()
-//	mr.Dump()
-func (m *Miniredis) Dump() string {
+//	mr.DebugDump()
+func (m *Miniredis) DebugDump() string {
 	m.Lock()
 	defer m.Unlock()