///////////////////////////////////////////////////////////////////////////////// // // Copyright (C) 2026- Equinor ASA // // ResInsight is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY // WARRANTY; without even the implied warranty of MERCHANTABILITY or // FITNESS FOR A PARTICULAR PURPOSE. // // See the GNU General Public License at // for more details. // ///////////////////////////////////////////////////////////////////////////////// #include "gtest/gtest.h" #include "RiaTestDataDirectory.h" #include "RimWorkflow.h" #include "RimWorkflowDefinitionTools.h" #include "RimWorkflowJob.h" #include "RimWorkflowTaskInput.h" #include "RimWorkflowValidationTools.h" #include #include #include #include #include namespace { RimWorkflowDefinition loadDataDefinition() { QFile file( QString( "%1/RimWorkflowDefinition/load_data.json" ).arg( TEST_DATA_DIR ) ); EXPECT_TRUE( file.open( QIODevice::ReadOnly ) ); auto definition = RimWorkflowDefinitionTools::fromJson( QJsonDocument::fromJson( file.readAll() ).object() ); EXPECT_TRUE( definition.has_value() ); return definition.value_or( RimWorkflowDefinition() ); } QJsonArray graphTasks( const RimWorkflowDefinition& definition ) { return RimWorkflowDefinitionTools::graphFromDefinition( definition, true ).value( "tasks" ).toArray(); } QString pathValue( const RimWorkflowJob& job, const QString& taskName ) { return job.inputValues().value( taskName ).toObject().value( "path" ).toString(); } } // namespace //-------------------------------------------------------------------------------------------------- TEST( RimWorkflowJobSync, oneTaskInputPerTask ) { const auto definition = loadDataDefinition(); RimWorkflowJob job; job.syncTaskInputs( graphTasks( definition ) ); ASSERT_EQ( 4u, job.taskInputs().size() ); EXPECT_EQ( "connect_to_resinsight", job.taskInputs()[0]->taskName() ); EXPECT_EQ( 0u, job.taskInputs()[0]->count() ); EXPECT_EQ( "resinsight.load_model", job.taskInput( "load_model" )->taskType() ); EXPECT_EQ( "/path/to/grid.roff", pathValue( job, "load_model" ) ); // Tasks without config fields are not written EXPECT_FALSE( job.inputValues().contains( "connect_to_resinsight" ) ); EXPECT_EQ( QJsonArray( { "/path/to/property.roffasc" } ), job.literalInputValues().value( "import_grid_property" ).toObject().value( "paths" ).toArray() ); QTemporaryDir directory; const QString path = job.writeInputYaml( directory.filePath( "input.yaml" ) ); QFile file( path ); ASSERT_TRUE( file.open( QIODevice::ReadOnly ) ); EXPECT_EQ( job.inputValues(), QJsonDocument::fromJson( file.readAll() ).object() ); } //-------------------------------------------------------------------------------------------------- TEST( RimWorkflowJobSync, valuesFollowRenamesAndRemovals ) { auto definition = loadDataDefinition(); RimWorkflowJob job; job.syncTaskInputs( graphTasks( definition ) ); RimWorkflowTaskInput* loadModel = job.taskInput( "load_model" ); // The binding object and its value are kept when the task is renamed auto renamed = RimWorkflowDefinitionTools::renameTask( definition, "load_model", "load_grid" ); ASSERT_TRUE( renamed.has_value() ); renamed->inputs["load_grid"] = QJsonObject(); job.syncTaskInputs( graphTasks( renamed.value() ), { { "load_model", "load_grid" } } ); EXPECT_EQ( loadModel, job.taskInput( "load_grid" ) ); EXPECT_EQ( "/path/to/grid.roff", pathValue( job, "load_grid" ) ); // Removing the task keeps its values aside, so undo brings them back auto removed = RimWorkflowDefinitionTools::removeTask( renamed.value(), "load_grid" ); ASSERT_TRUE( removed.has_value() ); job.syncTaskInputs( graphTasks( removed.value() ) ); EXPECT_EQ( nullptr, job.taskInput( "load_grid" ) ); job.syncTaskInputs( graphTasks( renamed.value() ) ); EXPECT_EQ( "/path/to/grid.roff", pathValue( job, "load_grid" ) ); // And through a rename back job.syncTaskInputs( graphTasks( removed.value() ) ); auto restored = renamed.value(); ASSERT_TRUE( restored.findNode( "load_grid" ) ); restored.findNode( "load_grid" )->name = "load_model"; restored.inputs.remove( "load_grid" ); for ( auto& edge : restored.edges ) { if ( edge.from == "load_grid" ) edge.from = "load_model"; } job.syncTaskInputs( graphTasks( removed.value() ), { { "load_grid", "load_model" } } ); job.syncTaskInputs( graphTasks( restored ) ); EXPECT_EQ( "/path/to/grid.roff", pathValue( job, "load_model" ) ); } //-------------------------------------------------------------------------------------------------- TEST( RimWorkflowEditing, undoRedoAndDirtyState ) { RimWorkflow workflow; workflow.setUnsavedDefinition( loadDataDefinition() ); EXPECT_TRUE( workflow.isEditable() ); EXPECT_TRUE( workflow.isDirty() ); EXPECT_FALSE( workflow.canUndo() ); ASSERT_EQ( 1u, workflow.jobs().size() ); RimWorkflowJob* job = workflow.jobs().front(); EXPECT_EQ( "/path/to/grid.roff", pathValue( *job, "load_model" ) ); const int revision = workflow.revision(); auto result = workflow.applyEdit( RimWorkflowDefinitionTools::renameTask( workflow.definition(), "load_model", "load_grid" ), { { "load_model", "load_grid" } } ); ASSERT_TRUE( result.has_value() ); EXPECT_GT( workflow.revision(), revision ); EXPECT_TRUE( workflow.canUndo() ); EXPECT_EQ( "/path/to/grid.roff", pathValue( *job, "load_grid" ) ); EXPECT_TRUE( workflow.uiName().endsWith( " *" ) ); workflow.undo(); EXPECT_TRUE( workflow.definition().findNode( "load_model" ) ); EXPECT_EQ( "/path/to/grid.roff", pathValue( *job, "load_model" ) ); EXPECT_TRUE( workflow.canRedo() ); workflow.redo(); EXPECT_TRUE( workflow.definition().findNode( "load_grid" ) ); EXPECT_FALSE( workflow.canRedo() ); // Failed edits change nothing const auto before = workflow.definition(); EXPECT_FALSE( workflow.applyEdit( RimWorkflowDefinitionTools::renameTask( before, "load_grid", "bad name" ) ).has_value() ); EXPECT_EQ( before, workflow.definition() ); // Read-only workflows cannot be edited RimWorkflow readOnly; auto readOnlyDefinition = loadDataDefinition(); readOnlyDefinition.editable = false; readOnly.loadFromRegistered( QJsonObject{ { "id", "test.workflow" }, { "name", "workflow" }, { "definition", RimWorkflowDefinitionTools::toJson( readOnlyDefinition ) } } ); EXPECT_FALSE( readOnly.isEditable() ); EXPECT_FALSE( readOnly.isDirty() ); EXPECT_FALSE( readOnly.applyEdit( RimWorkflowDefinitionTools::setResultTask( readOnly.definition(), "" ) ).has_value() ); auto runSource = readOnly.prepareRunSource(); ASSERT_TRUE( runSource.has_value() ); EXPECT_EQ( QStringList( { "run", "--registered", "test.workflow" } ), runSource->baseArgs ); } //-------------------------------------------------------------------------------------------------- TEST( RimWorkflowEditing, editabilityOfInstalledAndDuplicatedWorkflows ) { // An installed workflow is read-only even when its definition is editable, // but keeps the editable flag so it can be duplicated RimWorkflow installed; installed.loadFromRegistered( QJsonObject{ { "id", "test.workflow" }, { "name", "workflow" }, { "definition", RimWorkflowDefinitionTools::toJson( loadDataDefinition() ) } } ); EXPECT_FALSE( installed.isEditable() ); EXPECT_TRUE( installed.definition().editable ); EXPECT_FALSE( installed.definition().readOnlyReasons.isEmpty() ); RimWorkflow duplicate; duplicate.setUnsavedDefinition( installed.definition() ); EXPECT_TRUE( duplicate.isEditable() ); EXPECT_TRUE( duplicate.definition().readOnlyReasons.isEmpty() ); // Unsupported structure (e.g. nested workflows) keeps a duplicate read-only auto nested = loadDataDefinition(); nested.nodes.front().extra = QJsonObject{ { "workflow", "other" } }; const QStringList structural = RimWorkflowDefinitionTools::structuralReadOnlyReasons( nested ); ASSERT_EQ( 1, structural.size() ); EXPECT_TRUE( structural.front().contains( "workflow" ) ); RimWorkflow nestedWorkflow; nestedWorkflow.setUnsavedDefinition( nested ); EXPECT_FALSE( nestedWorkflow.isEditable() ); EXPECT_EQ( structural, nestedWorkflow.definition().readOnlyReasons ); } //-------------------------------------------------------------------------------------------------- TEST( RimWorkflowValidationTools, issuesFromHelperResult ) { const QStringList nodes{ "load_model", "load_model_2", "import" }; const QJsonObject describeError{ { "message", "Missing config" }, { "task", "load_model" }, { "issues", QJsonArray{ QJsonObject{ { "field", "path" }, { "code", "missing" } } } } }; auto result = RimWorkflowValidationTools::issuesFromHelperResult( QJsonObject{ { "status", "ok" }, { "describe_error", describeError } }, nodes ); EXPECT_FALSE( result.describeSucceeded ); ASSERT_EQ( 1u, result.issues.size() ); EXPECT_EQ( "load_model", result.issues[0].task ); EXPECT_EQ( "path", result.issues[0].field ); EXPECT_EQ( RimWorkflowIssue::Severity::Error, result.issues[0].severity ); // The task is found from a quoted name in the message, preferring the longest match result = RimWorkflowValidationTools::issuesFromHelperResult( QJsonObject{ { "status", "invalid" }, { "error", QJsonObject{ { "message", "Task 'load_model_2' has a bad input" } } } }, nodes ); ASSERT_EQ( 1u, result.issues.size() ); EXPECT_EQ( "load_model_2", result.issues[0].task ); // Unknown tasks go to the workflow result = RimWorkflowValidationTools::issuesFromHelperResult( QJsonObject{ { "status", "invalid" }, { "error", QJsonObject{ { "message", "Broken" }, { "task", "other" } } } }, nodes ); ASSERT_EQ( 1u, result.issues.size() ); EXPECT_TRUE( result.issues[0].task.isEmpty() ); // Missing config values are warnings const QJsonObject describe{ { "tasks", QJsonArray{ QJsonObject{ { "name", "import" }, { "missing_config_fields", QJsonArray{ "paths" } } } } } }; result = RimWorkflowValidationTools::issuesFromHelperResult( QJsonObject{ { "status", "ok" }, { "describe", describe } }, nodes ); EXPECT_TRUE( result.describeSucceeded ); ASSERT_EQ( 1u, result.issues.size() ); EXPECT_EQ( RimWorkflowIssue::Severity::Warning, result.issues[0].severity ); EXPECT_EQ( "paths", result.issues[0].field ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- TEST( RimWorkflowValidationTools, issuesWithJobValues ) { const QJsonObject missingCase{ { "task", "select" }, { "field", "case" }, { "severity", "warning" }, { "message", RimWorkflowValidationTools::missingValueMessage( "case" ) } }; const QJsonObject otherIssue{ { "task", "select" }, { "field", "" }, { "severity", "error" }, { "message", "Broken" } }; // A value in the job removes the stale warning from describe QJsonArray issues = RimWorkflowValidationTools::issuesWithJobValues( "select", { missingCase, otherIssue }, { { "case", true } } ); ASSERT_EQ( 1, issues.size() ); EXPECT_EQ( "Broken", issues[0].toObject().value( "message" ).toString() ); // A missing value in the job gives one warning, even if describe also reported it issues = RimWorkflowValidationTools::issuesWithJobValues( "select", { missingCase }, { { "case", false } } ); ASSERT_EQ( 1, issues.size() ); EXPECT_EQ( "case", issues[0].toObject().value( "field" ).toString() ); EXPECT_EQ( "warning", issues[0].toObject().value( "severity" ).toString() ); // Fields the job does not bind keep the warnings from describe issues = RimWorkflowValidationTools::issuesWithJobValues( "select", { missingCase }, {} ); EXPECT_EQ( 1, issues.size() ); }