fix logic error on multiple test run creation + various renamings etc

mocks/scenario_testrun_repository.go

@@ -12,10 +12,13 @@ type ScenarioTestrunRepository struct {
 	mock.Mock
 }
 
-func (s *ScenarioTestrunRepository) CreateTestRun(ctx context.Context, tx repositories.Transaction, testrunID string,
-	input models.ScenarioTestRunInput,
+func (s *ScenarioTestrunRepository) CreateTestRun(
+	ctx context.Context,
+	tx repositories.Transaction,
+	testrunId string,
+	input models.ScenarioTestRunCreateDbInput,
 ) error {
-	args := s.Called(ctx, tx, testrunID, input)
+	args := s.Called(ctx, tx, testrunId, input)
 	return args.Error(0)
 }
 
@@ -26,8 +29,7 @@ func (s *ScenarioTestrunRepository) UpdateTestRunStatus(ctx context.Context, exe
 	return args.Error(0)
 }
 
-func (s *ScenarioTestrunRepository) GetTestRunByLiveVersionID(ctx context.Context, exec repositories.Executor,
-	liveVersionID string,
+func (s *ScenarioTestrunRepository) GetTestRunByLiveVersionID(ctx context.Context, exec repositories.Executor, liveVersionID string,
 ) (*models.ScenarioTestRun, error) {
 	args := s.Called(ctx, exec, liveVersionID)
 	if args.Get(0) == nil {
@@ -36,16 +38,6 @@ func (s *ScenarioTestrunRepository) GetTestRunByLiveVersionID(ctx context.Contex
 	return args.Get(0).(*models.ScenarioTestRun), args.Error(1)
 }
 
-func (s *ScenarioTestrunRepository) GetActiveTestRunByScenarioIterationID(ctx context.Context,
-	exec repositories.Executor, scenarioID string,
-) (*models.ScenarioTestRun, error) {
-	args := s.Called(ctx, exec, scenarioID)
-	if args.Get(0) == nil {
-		return nil, args.Error(1)
-	}
-	return args.Get(0).(*models.ScenarioTestRun), args.Error(1)
-}
-
 func (s *ScenarioTestrunRepository) GetTestRunByID(ctx context.Context, exec repositories.Executor, testrunID string) (models.ScenarioTestRun, error) {
 	args := s.Called(ctx, exec, testrunID)
 	return args.Get(0).(models.ScenarioTestRun), args.Error(1)

models/scenario_testrun.go

@@ -52,6 +52,21 @@ type ScenarioTestRun struct {
 }
 
 type ScenarioTestRunInput struct {
+	ScenarioId         string
+	PhantomIterationId string
+	EndDate            time.Time
+}
+
+func (i ScenarioTestRunInput) CreateDbInput(liveIterationId string) ScenarioTestRunCreateDbInput {
+	return ScenarioTestRunCreateDbInput{
+		ScenarioId:         i.ScenarioId,
+		PhantomIterationId: i.PhantomIterationId,
+		LiveScenarioId:     liveIterationId,
+		EndDate:            i.EndDate,
+	}
+}
+
+type ScenarioTestRunCreateDbInput struct {
 	ScenarioId         string
 	PhantomIterationId string
 	LiveScenarioId     string

repositories/scenario_testrun.go

@@ -10,13 +10,17 @@ import (
 )
 
 type ScenarioTestRunRepository interface {
-	CreateTestRun(ctx context.Context, tx Transaction, testrunID string,
-		input models.ScenarioTestRunInput) error
-	GetActiveTestRunByScenarioIterationID(ctx context.Context, exec Executor,
-		scenarioIterationID string) (*models.ScenarioTestRun, error)
+	CreateTestRun(
+		ctx context.Context,
+		tx Transaction,
+		testrunId string,
+		input models.ScenarioTestRunCreateDbInput,
+	) error
 	ListTestRunsByScenarioID(ctx context.Context, exec Executor, scenarioID string) ([]models.ScenarioTestRun, error)
-	GetTestRunByLiveVersionID(ctx context.Context,
-		exec Executor, liveVersionID string,
+	GetTestRunByLiveVersionID(
+		ctx context.Context,
+		exec Executor,
+		liveVersionID string,
 	) (*models.ScenarioTestRun, error)
 	UpdateTestRunStatus(ctx context.Context, exec Executor,
 		scenarioIterationID string, status models.TestrunStatus,
@@ -34,7 +38,7 @@ func (repo *MarbleDbRepository) CreateTestRun(
 	ctx context.Context,
 	tx Transaction,
 	testrunID string,
-	input models.ScenarioTestRunInput,
+	input models.ScenarioTestRunCreateDbInput,
 ) error {
 	if err := validateMarbleDbExecutor(tx); err != nil {
 		return err
@@ -84,24 +88,6 @@ func (repo *MarbleDbRepository) UpdateTestRunStatus(ctx context.Context, exec Ex
 	return err
 }
 
-func (repo *MarbleDbRepository) GetActiveTestRunByScenarioIterationID(
-	ctx context.Context, exec Executor, scenarioIterationID string,
-) (*models.ScenarioTestRun, error) {
-	if err := validateMarbleDbExecutor(exec); err != nil {
-		return nil, err
-	}
-	query := selectTestruns().
-		Where(squirrel.Eq{"scenario_iteration_id": scenarioIterationID}).
-		Where(squirrel.Eq{"status": models.Up.String()})
-
-	return SqlToOptionalModel(
-		ctx,
-		exec,
-		query,
-		dbmodels.AdaptScenarioTestrun,
-	)
-}
-
 func (repo *MarbleDbRepository) GetTestRunByLiveVersionID(
 	ctx context.Context, exec Executor, liveVersionID string,
 ) (*models.ScenarioTestRun, error) {
@@ -111,12 +97,7 @@ func (repo *MarbleDbRepository) GetTestRunByLiveVersionID(
 	query := selectTestruns().
 		Where(squirrel.Eq{"live_scenario_iteration_id": liveVersionID}).
 		OrderBy("created_at DESC")
-	testruns, err := SqlToListOfModels(
-		ctx,
-		exec,
-		query,
-		dbmodels.AdaptScenarioTestrun,
-	)
+	testruns, err := SqlToListOfModels(ctx, exec, query, dbmodels.AdaptScenarioTestrun)
 	if err != nil {
 		return nil, err
 	}

usecases/evaluate_scenario/evaluate_scenario.go

@@ -189,26 +189,22 @@ func EvalTestRunScenario(ctx context.Context,
 		),
 	)
 	defer span.End()
-	testrun, errTr := repositories.ScenarioTestRunRepository.GetTestRunByLiveVersionID(ctx, exec, *params.Scenario.LiveVersionID)
-	if errTr != nil {
-		return models.ScenarioExecution{}, errors.Wrap(errTr,
-			"error getting testrun  in EvalTestRunScenario")
+	testrun, err := repositories.ScenarioTestRunRepository.GetTestRunByLiveVersionID(ctx, exec, *params.Scenario.LiveVersionID)
+	if err != nil {
+		return models.ScenarioExecution{}, err
 	}
 	if testrun == nil || testrun.Status != models.Up {
 		return models.ScenarioExecution{}, nil
 	}
-	scenario, errScenario := repositories.ScenarioRepository.GetScenarioByLiveScenarioIterationId(
-		ctx, exec, testrun.ScenarioLiveIterationId)
-	if errScenario != nil {
-		return models.ScenarioExecution{}, errors.Wrap(errTr,
-			"error getting scenario  in EvalTestRunScenario")
+	scenario, err := repositories.ScenarioRepository.GetScenarioByLiveScenarioIterationId(ctx, exec, testrun.ScenarioLiveIterationId)
+	if err != nil {
+		return models.ScenarioExecution{}, err
 	}
 	if scenario.Id == "" {
 		logger.ErrorContext(ctx, "the live version iteration associated to the current testrun does not match with the actual live scenario iteration")
 		return models.ScenarioExecution{}, nil
 	}
-	testRunIterationId, err := repositories.EvalTestRunScenarioRepository.GetTestRunIterationIdByScenarioId(
-		ctx, exec, params.Scenario.Id)
+	testRunIterationId, err := repositories.EvalTestRunScenarioRepository.GetTestRunIterationIdByScenarioId(ctx, exec, params.Scenario.Id)
 	if err != nil {
 		return models.ScenarioExecution{}, errors.Wrap(err,
 			"error getting testrun scenario iteration in EvalTestRunScenario")
@@ -218,14 +214,12 @@ func EvalTestRunScenario(ctx context.Context,
 	}
 	testRunIteration, err := repositories.EvalScenarioRepository.GetScenarioIteration(ctx, exec, *testRunIterationId)
 	if err != nil {
-		return models.ScenarioExecution{}, errors.Wrap(err,
-			"error getting testrun scenario iteration in EvalTestRunScenario")
+		return models.ScenarioExecution{}, err
 	}
 
-	se, errSe := processScenarioIteration(ctx, params, testRunIteration, repositories, start, logger, exec)
-	if errSe != nil {
-		return models.ScenarioExecution{}, errors.Wrap(errSe,
-			"error processing scenario iteration in EvalTestRunScenario")
+	se, err = processScenarioIteration(ctx, params, testRunIteration, repositories, start, logger, exec)
+	if err != nil {
+		return models.ScenarioExecution{}, err
 	}
 	se.TestRunId = testrun.Id
 	return se, nil

usecases/scenario_testrun_usecase.go

@@ -2,7 +2,6 @@ package usecases
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/checkmarble/marble-backend/models"
 	"github.com/checkmarble/marble-backend/pure_utils"
@@ -32,7 +31,8 @@ func (usecases *UsecasesWithCreds) NewScenarioTestRunUseCase() ScenarioTestRunUs
 	}
 }
 
-func (usecase *ScenarioTestRunUsecase) CreateScenarioTestRun(ctx context.Context,
+func (usecase *ScenarioTestRunUsecase) CreateScenarioTestRun(
+	ctx context.Context,
 	organizationId string,
 	input models.ScenarioTestRunInput,
 ) (models.ScenarioTestRun, error) {
@@ -41,21 +41,10 @@ func (usecase *ScenarioTestRunUsecase) CreateScenarioTestRun(ctx context.Context
 	}
 	exec := usecase.executorFactory.NewExecutor()
 
-	// we should not have any existing testrun for this scenario
-	existingTestrun, err := usecase.repository.GetActiveTestRunByScenarioIterationID(ctx, exec, input.PhantomIterationId)
-	if err != nil {
-		return models.ScenarioTestRun{}, errors.Wrap(err,
-			"error while fetching entries to find an existing testrun")
-	}
-	if existingTestrun != nil {
-		return models.ScenarioTestRun{}, errors.Wrap(models.ErrTestRunAlreadyExist,
-			fmt.Sprintf("the scenario %s has a running testrun", input.ScenarioId))
-	}
-
 	// we should have a live version running
-	scenario, errScenario := usecase.scenarioRepository.GetScenarioById(ctx, exec, input.ScenarioId)
-	if errScenario != nil {
-		return models.ScenarioTestRun{}, errScenario
+	scenario, err := usecase.scenarioRepository.GetScenarioById(ctx, exec, input.ScenarioId)
+	if err != nil {
+		return models.ScenarioTestRun{}, err
 	}
 	if scenario.LiveVersionID == nil {
 		return models.ScenarioTestRun{}, models.ErrScenarioHasNoLiveVersion
@@ -65,6 +54,16 @@ func (usecase *ScenarioTestRunUsecase) CreateScenarioTestRun(ctx context.Context
 		return models.ScenarioTestRun{}, models.ErrWrongIterationForTestRun
 	}
 
+	// we should not have any existing testrun for this scenario
+	existingTestrun, err := usecase.repository.GetTestRunByLiveVersionID(ctx, exec, *scenario.LiveVersionID)
+	if err != nil {
+		return models.ScenarioTestRun{}, err
+	}
+	if existingTestrun != nil {
+		return models.ScenarioTestRun{}, errors.Wrapf(models.ErrTestRunAlreadyExist,
+			"the scenario %s has a running testrun", input.ScenarioId)
+	}
+
 	indexesToCreate, numPending, err := usecase.clientDbIndexEditor.GetIndexesToCreate(
 		ctx,
 		organizationId,
@@ -79,14 +78,14 @@ func (usecase *ScenarioTestRunUsecase) CreateScenarioTestRun(ctx context.Context
 	}
 
 	// keep track of the live version associated to the current testrun
-	input.LiveScenarioId = *scenario.LiveVersionID
+	repoInput := input.CreateDbInput(*scenario.LiveVersionID)
 	testRunId := pure_utils.NewPrimaryKey(organizationId)
 
 	tr, err := executor_factory.TransactionReturnValue(
 		ctx,
 		usecase.transactionFactory,
 		func(tx repositories.Transaction) (models.ScenarioTestRun, error) {
-			if err := usecase.repository.CreateTestRun(ctx, tx, testRunId, input); err != nil {
+			if err := usecase.repository.CreateTestRun(ctx, tx, testRunId, repoInput); err != nil {
 				return models.ScenarioTestRun{}, err
 			}
 			result, err := usecase.repository.GetTestRunByID(ctx, tx, testRunId)

usecases/scenario_testrun_usecase_test.go

@@ -59,13 +59,13 @@ func (suite *ScenarioTestrunTestSuite) TestActivateScenarioTestRun() {
 		PhantomIterationId: "b53fcdd9-4909-4167-9b22-7e36a065ffbd",
 		ScenarioId:         "b6f0c253-ca06-4a5c-a208-9d5a537ca827",
 		EndDate:            time.Now(),
-		LiveScenarioId:     "b76359b2-9806-40f1-9fee-7ea18c797b2e",
 	}
 	output := models.ScenarioTestRun{
 		ScenarioIterationId: "b53fcdd9-4909-4167-9b22-7e36a065ffbd",
 		ScenarioId:          "b6f0c253-ca06-4a5c-a208-9d5a537ca827",
 		Status:              models.Up,
 	}
+	liveVersionID := "b76359b2-9806-40f1-9fee-7ea18c797b2e"
 	suite.clientDbIndexEditor.On("GetIndexesToCreate", suite.ctx, suite.organizationId, mock.Anything).Return(
 		[]models.ConcreteIndex{
 			{
@@ -77,17 +77,17 @@ func (suite *ScenarioTestrunTestSuite) TestActivateScenarioTestRun() {
 		suite.organizationId,
 		mock.Anything).Return(nil)
 	suite.executorFactory.On("NewExecutor").Return(suite.transaction)
-	liveVersionID := "b76359b2-9806-40f1-9fee-7ea18c797b2e"
 	suite.scenarioRepository.On("GetScenarioById",
 		suite.transaction, input.ScenarioId).Return(models.Scenario{
 		LiveVersionID: &liveVersionID,
 	}, nil)
 	suite.repository.On("GetTestRunByID", suite.ctx, suite.transaction,
 		mock.Anything).Return(output, nil)
 	suite.enforceSecurity.On("CreateTestRun", suite.organizationId).Return(nil)
-	suite.repository.On("CreateTestRun", suite.ctx, suite.transaction, mock.Anything, input).Return(nil)
-	suite.repository.On("GetActiveTestRunByScenarioIterationID", suite.ctx, suite.transaction,
-		input.PhantomIterationId).Return(nil, nil)
+	suite.repository.On("CreateTestRun", suite.ctx, suite.transaction, mock.Anything,
+		input.CreateDbInput(liveVersionID)).Return(nil)
+	suite.repository.On("GetTestRunByLiveVersionID", suite.ctx, suite.transaction,
+		liveVersionID).Return(nil, nil)
 
 	suite.clientDbIndexEditor.On("CreateIndexesAsyncForScenarioWithCallback", suite.ctx,
 		suite.organizationId, []models.ConcreteIndex{

usecases/scenarios/scenario_publisher.go

@@ -101,9 +101,9 @@ func (publisher ScenarioPublisher) PublishOrUnpublishIteration(
 }
 
 func (publisher ScenarioPublisher) shutDownTestRunIfNeeded(ctx context.Context, tx repositories.Transaction, liveVersionId string) error {
-	testrun, errTestrun := publisher.ScenarioTestRunRepository.GetTestRunByLiveVersionID(ctx, tx, liveVersionId)
-	if errTestrun != nil {
-		return errTestrun
+	testrun, err := publisher.ScenarioTestRunRepository.GetTestRunByLiveVersionID(ctx, tx, liveVersionId)
+	if err != nil {
+		return err
 	}
 	if testrun != nil && (testrun.Status == models.Up || testrun.Status == models.Pending) {
 		return publisher.ScenarioTestRunRepository.UpdateTestRunStatus(ctx, tx, testrun.Id, models.Down)