feat: endpoint to rerun test assertions on result

api/openapi.yaml

@@ -211,6 +211,7 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/TestRunResult"
+
   /tests/{testId}/results/{resultId}/select:
     get:
       tags:
@@ -245,6 +246,34 @@ paths:
                 items:
                   type: string
 
+  /tests/{testId}/results/{resultId}/rerun:
+    post:
+      tags:
+        - api
+      parameters:
+        - in: path
+          name: testId
+          schema:
+            type: string
+            format: uuid
+          required: true
+        - in: path
+          name: resultId
+          schema:
+            type: string
+            format: uuid
+          required: true
+      summary: "rerun a test result"
+      description: "rerun a test result"
+      operationId: rerunTestResult
+      responses:
+        200:
+          description: successful operation
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/TestRunResult"
+
   /tests/{testId}/results:
     get:
       tags:

server/app/app.go

@@ -82,7 +82,7 @@ func (a *App) Start() error {
 	runner.Start(5) // worker count. should be configurable
 	defer runner.Stop()
 
-	controller := httpServer.NewController(a.traceDB, a.db, runner)
+	controller := httpServer.NewController(a.traceDB, a.db, runner, assertionRunner)
 	apiApiController := openapi.NewApiApiController(controller)
 
 	router := openapi.NewRouter(apiApiController)

server/http/controller.go

@@ -16,16 +16,23 @@ import (
 )
 
 type controller struct {
-	traceDB tracedb.TraceDB
-	testDB  testdb.Repository
-	runner  executor.Runner
+	traceDB         tracedb.TraceDB
+	testDB          testdb.Repository
+	runner          executor.Runner
+	assertionRunner executor.AssertionRunner
 }
 
-func NewController(traceDB tracedb.TraceDB, testDB testdb.Repository, runner executor.Runner) openapi.ApiApiServicer {
+func NewController(
+	traceDB tracedb.TraceDB,
+	testDB testdb.Repository,
+	runner executor.Runner,
+	assertionRunner executor.AssertionRunner,
+) openapi.ApiApiServicer {
 	return &controller{
-		traceDB: traceDB,
-		testDB:  testDB,
-		runner:  runner,
+		traceDB:         traceDB,
+		testDB:          testDB,
+		runner:          runner,
+		assertionRunner: assertionRunner,
 	}
 }
 
@@ -292,3 +299,35 @@ func (s *controller) GetTestResultSelectedSpans(ctx context.Context, testID stri
 
 	return openapi.Response(http.StatusOK, selectedSpanIds), nil
 }
+
+func (s *controller) RerunTestResult(ctx context.Context, testID string, resultID string) (openapi.ImplResponse, error) {
+	test, err := s.testDB.GetTest(ctx, testID)
+	if err != nil {
+		return openapi.Response(http.StatusInternalServerError, err.Error()), err
+	}
+
+	result, err := s.testDB.GetResult(ctx, resultID)
+	if err != nil {
+		return openapi.Response(http.StatusInternalServerError, err.Error()), err
+	}
+
+	result.State = executor.TestRunStateAwaitingTestResults
+	err = s.testDB.UpdateResult(ctx, result)
+	if err != nil {
+		return openapi.Response(http.StatusInternalServerError, err.Error()), err
+	}
+
+	testDefinition, err := executor.ConvertAssertionsIntoTestDefinition(test.Assertions)
+	if err != nil {
+		return openapi.Response(http.StatusInternalServerError, err.Error()), err
+	}
+
+	assertionRequest := executor.AssertionRequest{
+		TestDefinition: testDefinition,
+		Result:         *result,
+	}
+
+	s.assertionRunner.RunAssertions(assertionRequest)
+
+	return openapi.Response(http.StatusOK, result), nil
+}

server/openapi/api.go

@@ -28,6 +28,7 @@ type ApiApiRouter interface {
 	GetTestResultSelectedSpans(http.ResponseWriter, *http.Request)
 	GetTestResults(http.ResponseWriter, *http.Request)
 	GetTests(http.ResponseWriter, *http.Request)
+	RerunTestResult(http.ResponseWriter, *http.Request)
 	RunTest(http.ResponseWriter, *http.Request)
 	UpdateAssertion(http.ResponseWriter, *http.Request)
 	UpdateTest(http.ResponseWriter, *http.Request)
@@ -49,6 +50,7 @@ type ApiApiServicer interface {
 	GetTestResultSelectedSpans(context.Context, string, string, string) (ImplResponse, error)
 	GetTestResults(context.Context, string, int32, int32) (ImplResponse, error)
 	GetTests(context.Context, int32, int32) (ImplResponse, error)
+	RerunTestResult(context.Context, string, string) (ImplResponse, error)
 	RunTest(context.Context, string) (ImplResponse, error)
 	UpdateAssertion(context.Context, string, string, Assertion) (ImplResponse, error)
 	UpdateTest(context.Context, string, Test) (ImplResponse, error)

server/openapi/api_api.go

@@ -110,6 +110,12 @@ func (c *ApiApiController) Routes() Routes {
 			"/api/tests",
 			c.GetTests,
 		},
+		{
+			"RerunTestResult",
+			strings.ToUpper("Post"),
+			"/api/tests/{testId}/results/{resultId}/rerun",
+			c.RerunTestResult,
+		},
 		{
 			"RunTest",
 			strings.ToUpper("Post"),
@@ -343,6 +349,24 @@ func (c *ApiApiController) GetTests(w http.ResponseWriter, r *http.Request) {
 
 }
 
+// RerunTestResult - rerun a test result
+func (c *ApiApiController) RerunTestResult(w http.ResponseWriter, r *http.Request) {
+	params := mux.Vars(r)
+	testIdParam := params["testId"]
+
+	resultIdParam := params["resultId"]
+
+	result, err := c.service.RerunTestResult(r.Context(), testIdParam, resultIdParam)
+	// If an error occurred, encode the error with the status code
+	if err != nil {
+		c.errorHandler(w, r, err, &result)
+		return
+	}
+	// If no error, encode the body and the result code
+	EncodeJSONResponse(result.Body, &result.Code, w)
+
+}
+
 // RunTest - run test
 func (c *ApiApiController) RunTest(w http.ResponseWriter, r *http.Request) {
 	params := mux.Vars(r)