chore(cms): Setting up OT editor for integration testing (#301)

* setting up editor for integration testing

* oops

* review changes

* review changes

Author: Varun-Sethu

backend/editor/OT/client_view.go

@@ -56,13 +56,12 @@ func (c *clientView) run(serverPipe pipe, terminatePipe alertLeaving) {
 				// push the update to the documentServer
 				if request, err := operations.ParseOperation(string(msg)); err == nil {
 					serverPipe(request)
-					continue
 				}
+			} else {
+				// todo: push a terminate signal to the client, also tell the server we're leaving
+				terminatePipe()
+				c.socket.Close()
 			}
-
-			// todo: push a terminate signal to the client, also tell the server we're leaving
-			terminatePipe()
-			c.socket.Close()
 		}
 	}
 }

backend/editor/OT/document_server.go

@@ -1,6 +1,7 @@
 package editor
 
 import (
+	"log"
 	"sync"
 
 	"cms.csesoc.unsw.edu.au/editor/OT/operations"
@@ -28,6 +29,7 @@ type clientState struct {
 	canSendOps bool
 }
 
+// todo: newDocumentServer should take an initial state
 func newDocumentServer() *documentServer {
 	// ideally state shouldn't be a string due to its immutability
 	// any update requires the allocation + copy of a new string in memory
@@ -114,21 +116,22 @@ func (s *documentServer) buildClientPipe(clientID int, workerWorkHandle chan fun
 			// apply op to clientView states
 			s.stateLock.Lock()
 
-			// TODO: apply operation
-			//	- Blockers:
-			//		- Gary's TLB
-			//		- Updated Traversal
-
 			// apply the operation locally and log the new operation
 			transformedOperation := s.transformOperation(op)
 			s.operationHistory = append(s.operationHistory, transformedOperation)
 
-			s.stateLock.Unlock()
-
-			if transformedOperation.IsNoOp {
-				return
+			if !transformedOperation.IsNoOp {
+				newState, err := op.ApplyTo(s.state)
+				if err != nil {
+					log.Fatal(err)
+					clientState.sendTerminateSignal <- empty{}
+				} else {
+					s.state = newState
+				}
 			}
 
+			s.stateLock.Unlock()
+
 			// propagate updates to all connected clients except this one
 			// if we send it to this clientView then we may deadlock the server and clientView
 			s.clientsLock.Lock()

backend/editor/OT/operations/traversal.go renamed to backend/editor/OT/operations/application.go

@@ -28,3 +28,13 @@ func Traverse(document cmsjson.AstNode, subpaths []int) (cmsjson.AstNode, cmsjso
 
 	return prev, curr, nil
 }
+
+func (op Operation) ApplyTo(document cmsjson.AstNode) (cmsjson.AstNode, error) {
+	parent, _, err := Traverse(document, op.Path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to apply operation %v at target site: %w", op, err)
+	}
+
+	applicationIndex := op.Path[len(op.Path)-1]
+	return op.Operation.Apply(parent, applicationIndex, op.OperationType)
+}

backend/editor/OT/operations/json_config.go

@@ -13,7 +13,7 @@ import (
 // cmsjson works with arbitrary schemas so this model can be changed on a whim
 // note that cmsjson does not check that the provided types implement the interface
 // so please check that everything works prior to running the CMS
-var cmsJsonConf = cmsjson.Configuration{
+var CmsJsonConf = cmsjson.Configuration{
 	// Registration for cmsmodel, when the LP is finally merged with CSESoc Projects
 	// this will also contain the registration for their data models
 	RegisteredTypes: map[reflect.Type]map[string]reflect.Type{

backend/editor/OT/operations/operation_model.go

@@ -38,7 +38,7 @@ var NoOperation = Operation{IsNoOp: true, Operation: Noop{}}
 // a Request object
 func ParseOperation(request string) (Operation, error) {
 	var operation Operation
-	if err := cmsjson.Unmarshall[Operation](cmsJsonConf, &operation, []byte(request)); err != nil {
+	if err := cmsjson.Unmarshall[Operation](CmsJsonConf, &operation, []byte(request)); err != nil {
 		return Operation{}, err
 	} else {
 		return operation, nil

backend/editor/OT/operations/tests/models_test.go renamed to backend/editor/OT/operations/tests/operation_application_test.go

@@ -0,0 +1,100 @@
+package editor
+
+import (
+	"cms.csesoc.unsw.edu.au/editor/OT/datamodel"
+	"cms.csesoc.unsw.edu.au/editor/OT/operations"
+	"cms.csesoc.unsw.edu.au/environment"
+	"cms.csesoc.unsw.edu.au/pkg/cmsjson"
+	"github.com/google/uuid"
+	"github.com/gorilla/websocket"
+)
+
+// testing_framework is a simple framework that can be used for performing integration tests on the concurrent editor
+// it allows for the observation of client behavior and tracking document server behavior
+type TestingClient struct {
+	underlyingClient *clientView
+	operationPipe    pipe
+	terminationPipe  func()
+}
+
+func (tC TestingClient) HasTerminated() bool { return len(tC.underlyingClient.sendTerminateSignal) > 0 }
+func (tC TestingClient) WasAcknowledged() bool {
+	if len(tC.underlyingClient.sendAcknowledgement) > 0 {
+		// potential "unexpected" blocking condition here but for the sake of testing its fine
+		// 	consider two goroutines one of them is this function
+		//		- this function reads the length and enters this if statement
+		//		- prior to the next statement another goroutine reads from the sendAck channel emptying it
+		//		- goroutine running this function is blocked until next ack (very tragic btw)
+		// for the purpose of testing tho this should be fine :)
+		<-tC.underlyingClient.sendAcknowledgement
+		return true
+	}
+	return false
+}
+
+func (tC TestingClient) GetReceivedOp() operations.Operation {
+	if len(tC.underlyingClient.sendOp) == 0 {
+		panic("testing client failure: expected a non-zero amount of received operations")
+	}
+
+	return <-tC.underlyingClient.sendOp
+}
+
+// GetServerState returns the current view that the server sees (as a string)
+func GetServerState(serverId uuid.UUID) string {
+	if !environment.IsTestingEnvironment() {
+		panic("method can only be called within the context of a test!")
+	}
+
+	connectedServer := GetDocumentServerFactoryInstance().FetchDocumentServer(serverId)
+	connectedServer.stateLock.Lock()
+	defer connectedServer.stateLock.Unlock()
+
+	return operations.CmsJsonConf.MarshallAST(connectedServer.state)
+}
+
+// CreateServer constructs a server with an initial state, it registers the server under the document manager
+// and returns the server's ID
+func CreateTestingServer(initState string) uuid.UUID {
+	if !environment.IsTestingEnvironment() {
+		panic("method can only be called within the context of a test!")
+	}
+
+	var err error
+	factory := GetDocumentServerFactoryInstance()
+	serverId := uuid.New()
+
+	factory.lock.Lock()
+	defer factory.lock.Unlock()
+	factory.activeServers[serverId] = newDocumentServer()
+
+	factory.activeServers[serverId].state, err = cmsjson.UnmarshallAST[datamodel.Document](operations.CmsJsonConf, initState)
+	if err != nil {
+		panic(err)
+	}
+
+	return serverId
+}
+
+// buildClients starts up n clients and returns their client views as an array
+func BuildTestingClient(serverId uuid.UUID, numClients int) []TestingClient {
+	if !environment.IsTestingEnvironment() {
+		panic("method can only be called within the context of a test!")
+	}
+
+	connectedServer := GetDocumentServerFactoryInstance().FetchDocumentServer(serverId)
+
+	clients := make([]TestingClient, numClients)
+	for clientId := range clients {
+		internalView := newClient(&websocket.Conn{})
+		operationPipe, terminationPipe := connectedServer.connectClient(internalView)
+
+		clients[clientId] = TestingClient{
+			underlyingClient: internalView,
+			operationPipe:    operationPipe,
+			terminationPipe:  terminationPipe,
+		}
+	}
+
+	return clients
+}

backend/editor/OT/testing_framework.go

@@ -0,0 +1,4 @@
+package tests
+
+// This test suite performs full integration tests on the entire concurrent editor
+//	the test suite is probably super fragile (as is the nature of a lot of integration tests :( ) but should give you assurance during any refactoring job you do

backend/editor/OT/tests/integration_test.go

@@ -0,0 +1,47 @@
+package cmsjson
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Marshall can potentially be a rather expensive operation
+// why? Strings in go are immutable, if we recursively modify
+// a string each invocation ends up allocation a new string on the heap
+// resulting in GC overhead :P
+func (c Configuration) MarshallAST(source AstNode) string {
+	asPrimitive, _ := source.JsonPrimitive()
+	asObject, _ := source.JsonObject()
+	asArray, _ := source.JsonArray()
+
+	switch {
+	case asPrimitive != nil:
+		return stringifyPrimitive(asPrimitive)
+	case asObject != nil:
+		result := strings.Builder{}
+		for _, node := range asObject {
+			result.WriteString(fmt.Sprintf("\"%s\": %s", node.GetKey(), c.MarshallAST(node)))
+		}
+
+		return fmt.Sprintf("{%s}", result.String())
+	default:
+		result := strings.Builder{}
+		for _, node := range asArray {
+			result.WriteString(c.MarshallAST(node) + ",")
+		}
+
+		return fmt.Sprintf("[%s]", result.String())
+	}
+}
+
+func stringifyPrimitive(primitive interface{}) string {
+	switch parsedPrimitive := primitive.(type) {
+	case string:
+		return "\"" + parsedPrimitive + "\""
+	case bool:
+		return strconv.FormatBool(parsedPrimitive)
+	default:
+		return strconv.FormatInt(parsedPrimitive.(int64), 10)
+	}
+}