CC-1299: Update RESP framework to accomodate Transaction tests elegantly

internal/resp/value/value.go

@@ -41,6 +41,7 @@ func NewIntegerValue(i int) Value {
 	return Value{
 		Type:    INTEGER,
 		integer: i,
+		bytes:   []byte(fmt.Sprintf("%d", i)),
 	}
 }
 
@@ -70,7 +71,8 @@ func NewArrayValue(arr []Value) Value {
 
 func NewNilValue() Value {
 	return Value{
-		Type: NIL,
+		Type:  NIL,
+		bytes: []byte("$-1\r\n"),
 	}
 }
 
@@ -94,6 +96,10 @@ func (v *Value) Integer() int {
 	return v.integer
 }
 
+func (v *Value) Error() string {
+	return string(v.String())
+}
+
 func (v *Value) FormattedString() string {
 	switch v.Type {
 	case SIMPLE_STRING:

internal/resp_assertions/error_assertion.go

@@ -0,0 +1,27 @@
+package resp_assertions
+
+import (
+	"fmt"
+
+	resp_value "github.com/codecrafters-io/redis-tester/internal/resp/value"
+)
+
+type ErrorAssertion struct {
+	ExpectedValue string
+}
+
+func NewErrorAssertion(expectedValue string) RESPAssertion {
+	return ErrorAssertion{ExpectedValue: expectedValue}
+}
+
+func (a ErrorAssertion) Run(value resp_value.Value) error {
+	if value.Type != resp_value.ERROR {
+		return fmt.Errorf("Expected error, got %s", value.Type)
+	}
+
+	if value.Error() != a.ExpectedValue {
+		return fmt.Errorf("Expected %s, got %s", a.ExpectedValue, value.Error())
+	}
+
+	return nil
+}

internal/resp_assertions/ordered_array_assertion.go

@@ -0,0 +1,50 @@
+package resp_assertions
+
+import (
+	"bytes"
+	"fmt"
+
+	resp_value "github.com/codecrafters-io/redis-tester/internal/resp/value"
+)
+
+// OrderedArrayAssertion : Order of the actual and expected values matters.
+// All RESP values are accepted as elements in this array.
+// We don't alter the ordering.
+type OrderedArrayAssertion struct {
+	ExpectedValue []resp_value.Value
+}
+
+func NewOrderedArrayAssertion(expectedValue []resp_value.Value) RESPAssertion {
+	return OrderedArrayAssertion{ExpectedValue: expectedValue}
+}
+
+func (a OrderedArrayAssertion) Run(value resp_value.Value) error {
+	if value.Type != resp_value.ARRAY {
+		return fmt.Errorf("Expected an array, got %s", value.Type)
+	}
+
+	if len(value.Array()) != len(a.ExpectedValue) {
+		return fmt.Errorf("Expected %d elements in array, got %d (%s)", len(a.ExpectedValue), len(value.Array()), value.FormattedString())
+	}
+
+	for i, expectedValue := range a.ExpectedValue {
+		actualElement := value.Array()[i]
+
+		if actualElement.Type != expectedValue.Type {
+			return fmt.Errorf("Expected element #%d to be a %s, got %s", i+1, expectedValue.Type, actualElement.Type)
+		}
+
+		if expectedValue.Bytes() == nil {
+			// This should never happen, but just in case
+			// This is the case for ArrayValues
+			return fmt.Errorf("CodeCrafters internal error. expectedValue Bytes of type: %s is nil", expectedValue.Type)
+		}
+
+		// ToDo: Equal or EqualFold ?
+		if !bytes.Equal(actualElement.Bytes(), expectedValue.Bytes()) {
+			return fmt.Errorf("Expected element #%d to be %s, got %s", i+1, expectedValue.FormattedString(), actualElement.FormattedString())
+		}
+	}
+
+	return nil
+}

internal/test_cases/multi_command_test_case.go

@@ -0,0 +1,35 @@
+package test_cases
+
+import (
+	"fmt"
+
+	resp_client "github.com/codecrafters-io/redis-tester/internal/resp/connection"
+	"github.com/codecrafters-io/redis-tester/internal/resp_assertions"
+	"github.com/codecrafters-io/tester-utils/logger"
+)
+
+// MultiCommandTestCase is a concise & easier way to define & run multiple SendCommandTestCase
+type MultiCommandTestCase struct {
+	Commands   [][]string
+	Assertions []resp_assertions.RESPAssertion
+}
+
+func (t *MultiCommandTestCase) RunAll(client *resp_client.RespConnection, logger *logger.Logger) error {
+	if len(t.Assertions) != len(t.Commands) {
+		return fmt.Errorf("Number of commands and assertions should be equal")
+	}
+
+	for i, command := range t.Commands {
+		setCommandTestCase := SendCommandTestCase{
+			Command:   command[0],
+			Args:      command[1:],
+			Assertion: t.Assertions[i],
+		}
+
+		if err := setCommandTestCase.Run(client, logger); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

internal/test_cases/transaction_test_case.go

@@ -0,0 +1,79 @@
+package test_cases
+
+import (
+	resp_client "github.com/codecrafters-io/redis-tester/internal/resp/connection"
+	resp_value "github.com/codecrafters-io/redis-tester/internal/resp/value"
+	"github.com/codecrafters-io/redis-tester/internal/resp_assertions"
+	"github.com/codecrafters-io/tester-utils/logger"
+)
+
+// TransactionTestCase is a test case where we initiate a transaction by sending "MULTI" command
+// Send a series of commands to the server expected back "QUEUED" for each command
+// Finally send "EXEC" command and expect the response to be the same as ResultArray
+//
+// RunAll will run all the steps in the Transaction execution. Alternatively, you
+// can run each step individually.
+type TransactionTestCase struct {
+	// All the CommandQueue will be sent in order to client
+	// And a string "QUEUED" will be expected
+	CommandQueue [][]string
+
+	// After queueing all the commands,
+	// if ResultArray is not empty, "EXEC" is sent
+	// And the response is compared with this ResultArray
+	ResultArray []resp_value.Value
+}
+
+func (t TransactionTestCase) RunAll(client *resp_client.RespConnection, logger *logger.Logger) error {
+	if err := t.RunMulti(client, logger); err != nil {
+		return err
+	}
+
+	if err := t.RunQueueAll(client, logger); err != nil {
+		return err
+	}
+
+	if len(t.ResultArray) > 0 {
+		if err := t.RunExec(client, logger); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (t TransactionTestCase) RunMulti(client *resp_client.RespConnection, logger *logger.Logger) error {
+	commandTest := SendCommandTestCase{
+		Command:   "MULTI",
+		Args:      []string{},
+		Assertion: resp_assertions.NewStringAssertion("OK"),
+	}
+
+	return commandTest.Run(client, logger)
+}
+
+func (t TransactionTestCase) RunQueueAll(client *resp_client.RespConnection, logger *logger.Logger) error {
+	for i, v := range t.CommandQueue {
+		logger.Debugf("Sent #%d command", i)
+		commandTest := SendCommandTestCase{
+			Command:   v[0],
+			Args:      v[1:],
+			Assertion: resp_assertions.NewStringAssertion("QUEUED"),
+		}
+		if err := commandTest.Run(client, logger); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (t TransactionTestCase) RunExec(client *resp_client.RespConnection, logger *logger.Logger) error {
+	setCommandTestCase := SendCommandTestCase{
+		Command:   "EXEC",
+		Args:      []string{},
+		Assertion: resp_assertions.NewOrderedArrayAssertion(t.ResultArray),
+	}
+
+	return setCommandTestCase.Run(client, logger)
+}

internal/test_txn_10.go

@@ -0,0 +1,53 @@
+package internal
+
+import (
+	"github.com/codecrafters-io/redis-tester/internal/redis_executable"
+	resp_value "github.com/codecrafters-io/redis-tester/internal/resp/value"
+
+	"github.com/codecrafters-io/redis-tester/internal/instrumented_resp_connection"
+	"github.com/codecrafters-io/redis-tester/internal/resp_assertions"
+	"github.com/codecrafters-io/redis-tester/internal/test_cases"
+	"github.com/codecrafters-io/tester-utils/test_case_harness"
+)
+
+func testTxErr(stageHarness *test_case_harness.TestCaseHarness) error {
+	b := redis_executable.NewRedisExecutable(stageHarness)
+	if err := b.Run(); err != nil {
+		return err
+	}
+
+	logger := stageHarness.Logger
+
+	client, err := instrumented_resp_connection.NewFromAddr(stageHarness, "localhost:6379", "client1")
+	if err != nil {
+		logFriendlyError(logger, err)
+		return err
+	}
+	defer client.Close()
+
+	multiCommandTestCase := test_cases.MultiCommandTestCase{
+		Commands: [][]string{
+			{"SET", "foo", "abc"},
+			{"SET", "bar", "7"},
+		},
+		Assertions: []resp_assertions.RESPAssertion{
+			resp_assertions.NewStringAssertion("OK"),
+			resp_assertions.NewStringAssertion("OK"),
+		},
+	}
+
+	if err := multiCommandTestCase.RunAll(client, logger); err != nil {
+		return err
+	}
+
+	transactionTestCase := test_cases.TransactionTestCase{
+		CommandQueue: [][]string{
+			{"INCR", "foo"},
+			{"INCR", "bar"},
+		},
+		ResultArray: []resp_value.Value{
+			resp_value.NewErrorValue("ERR value is not an integer or out of range"), resp_value.NewIntegerValue(8)},
+	}
+
+	return transactionTestCase.RunAll(client, logger)
+}

internal/test_txn_11.go

@@ -0,0 +1,82 @@
+package internal
+
+import (
+	"github.com/codecrafters-io/redis-tester/internal/redis_executable"
+	resp_connection "github.com/codecrafters-io/redis-tester/internal/resp/connection"
+	resp_value "github.com/codecrafters-io/redis-tester/internal/resp/value"
+	"github.com/codecrafters-io/redis-tester/internal/resp_assertions"
+
+	"github.com/codecrafters-io/redis-tester/internal/instrumented_resp_connection"
+	"github.com/codecrafters-io/redis-tester/internal/test_cases"
+	"github.com/codecrafters-io/tester-utils/test_case_harness"
+)
+
+func testTxMulti(stageHarness *test_case_harness.TestCaseHarness) error {
+	b := redis_executable.NewRedisExecutable(stageHarness)
+	if err := b.Run(); err != nil {
+		return err
+	}
+
+	logger := stageHarness.Logger
+
+	var clients []*resp_connection.RespConnection
+
+	for i := 0; i < 3; i++ {
+		client, err := instrumented_resp_connection.NewFromAddr(stageHarness, "localhost:6379", "client1")
+		if err != nil {
+			logFriendlyError(logger, err)
+			return err
+		}
+		clients = append(clients, client)
+		defer client.Close()
+	}
+
+	for i, client := range clients {
+		multiCommandTestCase := test_cases.MultiCommandTestCase{
+			Commands: [][]string{
+				{"SET", "bar", "7"},
+				{"INCR", "foo"},
+			},
+			Assertions: []resp_assertions.RESPAssertion{
+				resp_assertions.NewStringAssertion("OK"),
+				resp_assertions.NewIntegerAssertion(i + 1),
+			},
+		}
+
+		if err := multiCommandTestCase.RunAll(client, logger); err != nil {
+			return err
+		}
+	}
+
+	for i, client := range clients {
+		transactionTestCase := test_cases.TransactionTestCase{
+			CommandQueue: [][]string{
+				{"INCR", "foo"},
+				{"INCR", "bar"},
+			},
+			ResultArray: []resp_value.Value{resp_value.NewIntegerValue(4 + i), resp_value.NewIntegerValue(8 + i)},
+		}
+		if err := transactionTestCase.RunMulti(client, logger); err != nil {
+			return err
+		}
+
+		if err := transactionTestCase.RunQueueAll(client, logger); err != nil {
+			return err
+		}
+	}
+
+	for i, client := range clients {
+		transactionTestCase := test_cases.TransactionTestCase{
+			CommandQueue: [][]string{
+				{"INCR", "foo"},
+				{"INCR", "bar"},
+			},
+			ResultArray: []resp_value.Value{resp_value.NewIntegerValue(4 + i), resp_value.NewIntegerValue(8 + i)},
+		}
+		if err := transactionTestCase.RunExec(client, logger); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

internal/test_txn_8.go

@@ -0,0 +1,38 @@
+package internal
+
+import (
+	"github.com/codecrafters-io/redis-tester/internal/redis_executable"
+	resp_value "github.com/codecrafters-io/redis-tester/internal/resp/value"
+
+	"github.com/codecrafters-io/redis-tester/internal/instrumented_resp_connection"
+	"github.com/codecrafters-io/redis-tester/internal/test_cases"
+	"github.com/codecrafters-io/tester-utils/test_case_harness"
+)
+
+func testTxSuccess(stageHarness *test_case_harness.TestCaseHarness) error {
+	b := redis_executable.NewRedisExecutable(stageHarness)
+	if err := b.Run(); err != nil {
+		return err
+	}
+
+	logger := stageHarness.Logger
+
+	client, err := instrumented_resp_connection.NewFromAddr(stageHarness, "localhost:6379", "client1")
+	if err != nil {
+		logFriendlyError(logger, err)
+		return err
+	}
+	defer client.Close()
+
+	transactionTestCase := test_cases.TransactionTestCase{
+		CommandQueue: [][]string{
+			{"SET", "foo", "6"},
+			{"INCR", "foo"},
+			{"INCR", "bar"},
+			{"GET", "bar"},
+		},
+		ResultArray: []resp_value.Value{resp_value.NewSimpleStringValue("OK"), resp_value.NewIntegerValue(7), resp_value.NewIntegerValue(1), resp_value.NewBulkStringValue("1")},
+	}
+
+	return transactionTestCase.RunAll(client, logger)
+}