- Fix tests handling CLI args

- improve docstrings

taipy/core/_core.py

@@ -51,8 +51,8 @@ class Core:
         """
         Start a Core service.
 
-        This function checks the configuration, manages application's version,
-        and starts a dispatcher and lock the Config.
+        This function checks and lock the configuration, manages application's version,
+        and starts a job dispatcher.
         """
         if self.__class__._is_running:
             raise CoreServiceIsAlreadyRunning
@@ -61,10 +61,6 @@ class Core:
             self.__class__._is_running = True
 
         self._manage_version_and_block_config()
-
-        if self._orchestrator is None:
-            self._orchestrator = _OrchestratorFactory._build_orchestrator()
-
         self.__start_dispatcher(force_restart)
 
     def stop(self, wait: bool = True, timeout: Optional[float] = None):
@@ -91,7 +87,7 @@ class Core:
     @classmethod
     def _manage_version_and_block_config(cls):
         """
-        Manage the application's version and block the Config for update.
+        Manage the application's version and block the Config from updates.
         """
         if cls._version_is_initialized:
             return
@@ -122,6 +118,9 @@ class Core:
         _init_backup_file_with_storage_folder()
 
     def __start_dispatcher(self, force_restart):
+        if self._orchestrator is None:
+            self._orchestrator = _OrchestratorFactory._build_orchestrator()
+
         if dispatcher := _OrchestratorFactory._build_dispatcher(force_restart=force_restart):
             self._dispatcher = dispatcher
 

taipy/core/taipy.py

@@ -836,10 +836,11 @@ def create_scenario(
 ) -> Scenario:
     """Create and return a new scenario based on a scenario configuration.
 
-    If the scenario belongs to a cycle, a cycle (corresponding to the _creation_date_
-    and the configuration frequency attribute) is created if it does not exist yet.
+    This function checks and lock the configuration, manages application's version,
+    and creates a new scenario from the scenario configuration provided.
 
-    By creating the scenario entity, updating the Configuration is blocked.
+    If the scenario belongs to a cycle, the cycle (corresponding to the _creation_date_
+    and the configuration frequency attribute) is created if it does not exist yet.
 
     Parameters:
         config (ScenarioConfig^): The scenario configuration used to create a new scenario.
@@ -849,6 +850,10 @@ def create_scenario(
 
     Returns:
         The new scenario.
+
+    Raises:
+        SystemExit: If the configuration check returns some errors.
+
     """
     Core._manage_version_and_block_config()
 
@@ -858,7 +863,8 @@ def create_scenario(
 def create_global_data_node(config: DataNodeConfig) -> DataNode:
     """Create and return a new GLOBAL data node from a data node configuration.
 
-    By creating the data node entity, updating the Configuration is blocked.
+    This function checks and lock the configuration, manages application's version,
+    and creates the new data node from the data node configuration provided.
 
     Parameters:
         config (DataNodeConfig^): The data node configuration. It must have a `GLOBAL` scope.
@@ -868,6 +874,7 @@ def create_global_data_node(config: DataNodeConfig) -> DataNode:
 
     Raises:
         DataNodeConfigIsNotGlobal^: If the data node configuration does not have GLOBAL scope.
+        SystemExit: If the configuration check returns some errors.
     """
     # Check if the data node config has GLOBAL scope
     if config.scope is not Scope.GLOBAL:

tests/core/_orchestrator/_dispatcher/test_dispatcher__execute_job.py

@@ -10,6 +10,7 @@
 # specific language governing permissions and limitations under the License.
 
 from unittest import mock
+from unittest.mock import patch
 
 import taipy
 from taipy.config.config import Config
@@ -46,58 +47,61 @@ def test_can_execute():
 
 
 def test_execute_job():
-    scenario = create_scenario()
-    scenario.t1.skippable = True  # make the job skippable
-    scenario.dn.lock_edit()  # lock output edit
-    job = Job(JobId("id"), scenario.t1, "submit_id", TaskId("id"))
-    _JobManagerFactory._build_manager()._set(job)
-    with mock.patch("taipy.core._orchestrator._dispatcher._job_dispatcher._JobDispatcher._dispatch") as mck_1:
-        with mock.patch("taipy.core._orchestrator._dispatcher._job_dispatcher._JobDispatcher._needs_to_run") as mck_2:
-            mck_2.return_value = True
-            dispatcher = _JobDispatcher(_OrchestratorFactory._build_orchestrator())
-            dispatcher._execute_job(job)
-
-            mck_2.assert_called_once_with(job.task)  # This should be called to check if job needs to run
-            mck_1.assert_called_once_with(job)
-            assert job.is_running()  # The job is not executed since the dispatch is mocked
-            assert scenario.dn.edit_in_progress  # outputs must NOT have been unlocked because the disptach is mocked
+    with patch("sys.argv", ["prog"]):
+        scenario = create_scenario()
+        scenario.t1.skippable = True  # make the job skippable
+        scenario.dn.lock_edit()  # lock output edit
+        job = Job(JobId("id"), scenario.t1, "submit_id", TaskId("id"))
+        _JobManagerFactory._build_manager()._set(job)
+        with mock.patch("taipy.core._orchestrator._dispatcher._job_dispatcher._JobDispatcher._dispatch") as mck_1:
+            with mock.patch("taipy.core._orchestrator._dispatcher._job_dispatcher._JobDispatcher._needs_to_run") as mck_2:
+                mck_2.return_value = True
+                dispatcher = _JobDispatcher(_OrchestratorFactory._build_orchestrator())
+                dispatcher._execute_job(job)
+
+                mck_2.assert_called_once_with(job.task)  # This should be called to check if job needs to run
+                mck_1.assert_called_once_with(job)
+                assert job.is_running()  # The job is not executed since the dispatch is mocked
+                assert scenario.dn.edit_in_progress  # outputs must NOT have been unlocked because the disptach is mocked
 
 
 def test_execute_job_to_skip():
-    scenario = create_scenario()
-    scenario.t1.skippable = True  # make the job skippable
-    scenario.dn.lock_edit()  # lock output edit
-    job = Job(JobId("id"), scenario.t1, "submit_id", TaskId("id"))
-    _JobManagerFactory._build_manager()._set(job)
+    with patch("sys.argv", ["prog"]):
+        scenario = create_scenario()
+        scenario.t1.skippable = True  # make the job skippable
+        scenario.dn.lock_edit()  # lock output edit
+        job = Job(JobId("id"), scenario.t1, "submit_id", TaskId("id"))
+        _JobManagerFactory._build_manager()._set(job)
 
-    with mock.patch("taipy.core._orchestrator._dispatcher._job_dispatcher._JobDispatcher._dispatch") as mck_1:
-        with mock.patch("taipy.core._orchestrator._dispatcher._job_dispatcher._JobDispatcher._needs_to_run") as mck_2:
-            mck_2.return_value = False
-            _JobDispatcher(_OrchestratorFactory._build_orchestrator())._execute_job(job)
+        with mock.patch("taipy.core._orchestrator._dispatcher._job_dispatcher._JobDispatcher._dispatch") as mck_1:
+            with mock.patch("taipy.core._orchestrator._dispatcher._job_dispatcher._JobDispatcher._needs_to_run") as mck_2:
+                mck_2.return_value = False
+                _JobDispatcher(_OrchestratorFactory._build_orchestrator())._execute_job(job)
 
-            assert job.is_skipped()
-            mck_1.assert_not_called()  # The job is expecting to be skipped, so it must not be dispatched
-            mck_2.assert_called_once_with(job.task)  # this must be called to check if the job needs to run
-            assert not scenario.dn.edit_in_progress  # outputs must have been unlocked
+                assert job.is_skipped()
+                mck_1.assert_not_called()  # The job is expecting to be skipped, so it must not be dispatched
+                mck_2.assert_called_once_with(job.task)  # this must be called to check if the job needs to run
+                assert not scenario.dn.edit_in_progress  # outputs must have been unlocked
 
 
 def test_execute_job_skippable_with_force():
-    scenario = create_scenario()
-    scenario.t1.skippable = True  # make the job skippable
-    scenario.dn.lock_edit()  # lock output edit
-    job = Job(JobId("id"), scenario.t1, "submit_id", TaskId("id"), force=True)
-    _JobManagerFactory._build_manager()._set(job)
-
-    with mock.patch("taipy.core._orchestrator._dispatcher._job_dispatcher._JobDispatcher._dispatch") as mck_1:
-        with mock.patch("taipy.core._orchestrator._dispatcher._job_dispatcher._JobDispatcher._needs_to_run") as mck_2:
-            mck_2.return_value = False
-            dispatcher = _JobDispatcher(_OrchestratorFactory._orchestrator)
-            dispatcher._execute_job(job)
-
-            mck_1.assert_called_once_with(job)  # This should be called to dispatch the job
-            mck_2.assert_not_called()  # This should NOT be called since we force the execution anyway
-            assert job.is_running()  # The job is not executed since the dispatch is mocked
-            assert scenario.dn.edit_in_progress  # outputs must NOT have been unlocked because the disptach is mocked
+    with patch("sys.argv", ["prog"]):
+        scenario = create_scenario()
+        scenario.t1.skippable = True  # make the job skippable
+        scenario.dn.lock_edit()  # lock output edit
+        job = Job(JobId("id"), scenario.t1, "submit_id", TaskId("id"), force=True)
+        _JobManagerFactory._build_manager()._set(job)
+
+        with mock.patch("taipy.core._orchestrator._dispatcher._job_dispatcher._JobDispatcher._dispatch") as mck_1:
+            with mock.patch("taipy.core._orchestrator._dispatcher._job_dispatcher._JobDispatcher._needs_to_run") as mck_2:
+                mck_2.return_value = False
+                dispatcher = _JobDispatcher(_OrchestratorFactory._orchestrator)
+                dispatcher._execute_job(job)
+
+                mck_1.assert_called_once_with(job)  # This should be called to dispatch the job
+                mck_2.assert_not_called()  # This should NOT be called since we force the execution anyway
+                assert job.is_running()  # The job is not executed since the dispatch is mocked
+                assert scenario.dn.edit_in_progress  # outputs must NOT have been unlocked because the disptach is mocked
 
 
 def test_execute_jobs_synchronously():

tests/core/_orchestrator/test_orchestrator__cancel_jobs.py

@@ -8,6 +8,8 @@
 # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 # an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
+from unittest.mock import patch
+
 from taipy import Job, JobId, Status
 from taipy.config import Config
 from taipy.core import taipy
@@ -55,80 +57,83 @@ def test_cancel_job_no_subsequent_jobs():
 
 
 def test_cancel_job_with_subsequent_blocked_jobs():
-    scenario = create_scenario()
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    job1 = orchestrator._lock_dn_output_and_create_job(scenario.t1, "s_id", "e_id")
-    job2 = orchestrator._lock_dn_output_and_create_job(scenario.t2, "s_id", "e_id")
-    job3 = orchestrator._lock_dn_output_and_create_job(scenario.t3, "s_id", "e_id")
-    job2bis = orchestrator._lock_dn_output_and_create_job(scenario.t2bis, "s_id", "e_id")
-    job1.pending()
-    job2.blocked()
-    job3.blocked()
-    job2bis.blocked()
-    orchestrator.blocked_jobs = [job2, job3, job2bis]
-
-    orchestrator.cancel_job(job1)
-
-    assert job1.is_canceled()
-    assert job2.is_abandoned()
-    assert job3.is_abandoned()
-    assert job2bis.is_abandoned()
-    assert not scenario.dn_0.edit_in_progress
-    assert not scenario.dn_1.edit_in_progress
-    assert not scenario.dn_2.edit_in_progress
-    assert not scenario.dn_3.edit_in_progress
-    assert orchestrator.blocked_jobs == []
+    with patch("sys.argv", ["prog"]):
+        scenario = create_scenario()
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        job1 = orchestrator._lock_dn_output_and_create_job(scenario.t1, "s_id", "e_id")
+        job2 = orchestrator._lock_dn_output_and_create_job(scenario.t2, "s_id", "e_id")
+        job3 = orchestrator._lock_dn_output_and_create_job(scenario.t3, "s_id", "e_id")
+        job2bis = orchestrator._lock_dn_output_and_create_job(scenario.t2bis, "s_id", "e_id")
+        job1.pending()
+        job2.blocked()
+        job3.blocked()
+        job2bis.blocked()
+        orchestrator.blocked_jobs = [job2, job3, job2bis]
+
+        orchestrator.cancel_job(job1)
+
+        assert job1.is_canceled()
+        assert job2.is_abandoned()
+        assert job3.is_abandoned()
+        assert job2bis.is_abandoned()
+        assert not scenario.dn_0.edit_in_progress
+        assert not scenario.dn_1.edit_in_progress
+        assert not scenario.dn_2.edit_in_progress
+        assert not scenario.dn_3.edit_in_progress
+        assert orchestrator.blocked_jobs == []
 
 
 def test_cancel_job_with_subsequent_jobs_and_parallel_jobs():
-    scenario = create_scenario()
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    job1 = orchestrator._lock_dn_output_and_create_job(scenario.t1, "s_id", "e_id")
-    job2 = orchestrator._lock_dn_output_and_create_job(scenario.t2, "s_id", "e_id")
-    job3 = orchestrator._lock_dn_output_and_create_job(scenario.t3, "s_id", "e_id")
-    job2bis = orchestrator._lock_dn_output_and_create_job(scenario.t2bis, "s_id", "e_id")
-    job1.completed()
-
-    job2.running()
-    job3.blocked()
-    job2bis.pending()
-    orchestrator.blocked_jobs = [job3]
-
-    orchestrator.cancel_job(job2)
-
-    assert job1.is_completed()
-    assert job2.is_canceled()
-    assert job3.is_abandoned()
-    assert job2bis.is_pending()
-    assert not scenario.dn_2.edit_in_progress
-    assert not scenario.dn_3.edit_in_progress
-    assert orchestrator.blocked_jobs == []
+    with patch("sys.argv", ["prog"]):
+        scenario = create_scenario()
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        job1 = orchestrator._lock_dn_output_and_create_job(scenario.t1, "s_id", "e_id")
+        job2 = orchestrator._lock_dn_output_and_create_job(scenario.t2, "s_id", "e_id")
+        job3 = orchestrator._lock_dn_output_and_create_job(scenario.t3, "s_id", "e_id")
+        job2bis = orchestrator._lock_dn_output_and_create_job(scenario.t2bis, "s_id", "e_id")
+        job1.completed()
+
+        job2.running()
+        job3.blocked()
+        job2bis.pending()
+        orchestrator.blocked_jobs = [job3]
+
+        orchestrator.cancel_job(job2)
+
+        assert job1.is_completed()
+        assert job2.is_canceled()
+        assert job3.is_abandoned()
+        assert job2bis.is_pending()
+        assert not scenario.dn_2.edit_in_progress
+        assert not scenario.dn_3.edit_in_progress
+        assert orchestrator.blocked_jobs == []
 
 
 def test_cancel_blocked_job_with_subsequent_blocked_jobs():
-    scenario = create_scenario()
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    job1 = orchestrator._lock_dn_output_and_create_job(scenario.t1, "s_id", "e_id")
-    job2 = orchestrator._lock_dn_output_and_create_job(scenario.t2, "s_id", "e_id")
-    job3 = orchestrator._lock_dn_output_and_create_job(scenario.t3, "s_id", "e_id")
-    job2bis = orchestrator._lock_dn_output_and_create_job(scenario.t2bis, "s_id", "e_id")
-    job1.blocked()
-    job2.blocked()
-    job3.blocked()
-    job2bis.blocked()
-    orchestrator.blocked_jobs = [job2, job3, job2bis]
-
-    orchestrator.cancel_job(job1)
-
-    assert job1.is_canceled()
-    assert job2.is_abandoned()
-    assert job3.is_abandoned()
-    assert job2bis.is_abandoned()
-    assert not scenario.dn_0.edit_in_progress
-    assert not scenario.dn_1.edit_in_progress
-    assert not scenario.dn_2.edit_in_progress
-    assert not scenario.dn_3.edit_in_progress
-    assert orchestrator.blocked_jobs == []
+    with patch("sys.argv", ["prog"]):
+        scenario = create_scenario()
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        job1 = orchestrator._lock_dn_output_and_create_job(scenario.t1, "s_id", "e_id")
+        job2 = orchestrator._lock_dn_output_and_create_job(scenario.t2, "s_id", "e_id")
+        job3 = orchestrator._lock_dn_output_and_create_job(scenario.t3, "s_id", "e_id")
+        job2bis = orchestrator._lock_dn_output_and_create_job(scenario.t2bis, "s_id", "e_id")
+        job1.blocked()
+        job2.blocked()
+        job3.blocked()
+        job2bis.blocked()
+        orchestrator.blocked_jobs = [job2, job3, job2bis]
+
+        orchestrator.cancel_job(job1)
+
+        assert job1.is_canceled()
+        assert job2.is_abandoned()
+        assert job3.is_abandoned()
+        assert job2bis.is_abandoned()
+        assert not scenario.dn_0.edit_in_progress
+        assert not scenario.dn_1.edit_in_progress
+        assert not scenario.dn_2.edit_in_progress
+        assert not scenario.dn_3.edit_in_progress
+        assert orchestrator.blocked_jobs == []
 
 
 def test_cancel_failed_job():

tests/core/_orchestrator/test_orchestrator__is_blocked.py

@@ -8,6 +8,7 @@
 # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 # an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
+from unittest.mock import patch
 
 from taipy.config import Config
 from taipy.core import taipy
@@ -20,137 +21,147 @@ def nothing(*args, **kwargs):
 
 
 def test_is_not_blocked_task_single_input():
-    inp = Config.configure_data_node("inp", default_data="DEFAULT")
-    t = Config.configure_task("the_task", nothing, [inp], [])
-    sc_conf = Config.configure_scenario("scenario", [t])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
+    with patch("sys.argv", ["prog"]):
+        inp = Config.configure_data_node("inp", default_data="DEFAULT")
+        t = Config.configure_task("the_task", nothing, [inp], [])
+        sc_conf = Config.configure_scenario("scenario", [t])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
 
-    res = orchestrator._is_blocked(scenario.the_task)
+        res = orchestrator._is_blocked(scenario.the_task)
 
-    assert res is False
+        assert res is False
 
 
 def test_is_not_blocked_task_multiple_input_and_output():
-    dn_0 = Config.configure_data_node("in_0", default_data="THIS")
-    dn_1 = Config.configure_data_node("in_1", default_data="IS")
-    dn_2 = Config.configure_data_node("in_2", default_data="DEFAULT")
-    out = Config.configure_data_node("output_dn")
-    t = Config.configure_task("the_task", nothing, [dn_0, dn_1, dn_2], [out])
-    sc_conf = Config.configure_scenario("scenario", [t])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
+    with patch("sys.argv", ["prog"]):
+        dn_0 = Config.configure_data_node("in_0", default_data="THIS")
+        dn_1 = Config.configure_data_node("in_1", default_data="IS")
+        dn_2 = Config.configure_data_node("in_2", default_data="DEFAULT")
+        out = Config.configure_data_node("output_dn")
+        t = Config.configure_task("the_task", nothing, [dn_0, dn_1, dn_2], [out])
+        sc_conf = Config.configure_scenario("scenario", [t])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
 
-    res = orchestrator._is_blocked(scenario.the_task)
+        res = orchestrator._is_blocked(scenario.the_task)
 
-    assert res is False
+        assert res is False
 
 
 def test_is_blocked_task_single_input_no_data():
-    inp = Config.configure_data_node("inp")
-    t = Config.configure_task("the_task", nothing, [inp], [])
-    sc_conf = Config.configure_scenario("scenario", [t])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
+    with patch("sys.argv", ["prog"]):
+        inp = Config.configure_data_node("inp")
+        t = Config.configure_task("the_task", nothing, [inp], [])
+        sc_conf = Config.configure_scenario("scenario", [t])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
 
-    res = orchestrator._is_blocked(scenario.the_task)
+        res = orchestrator._is_blocked(scenario.the_task)
 
-    assert res is True
+        assert res is True
 
 
 def test_is_blocked_task_single_input_edit_in_progress():
-    input_dn_cfg = Config.configure_data_node("inp", default_data=51)
-    t_cfg = Config.configure_task("the_task", nothing, [input_dn_cfg])
-    sc_conf = Config.configure_scenario("scenario", [t_cfg])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    scenario.inp.lock_edit()
+    with patch("sys.argv", ["prog"]):
+        input_dn_cfg = Config.configure_data_node("inp", default_data=51)
+        t_cfg = Config.configure_task("the_task", nothing, [input_dn_cfg])
+        sc_conf = Config.configure_scenario("scenario", [t_cfg])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        scenario.inp.lock_edit()
 
-    res = orchestrator._is_blocked(scenario.the_task)
+        res = orchestrator._is_blocked(scenario.the_task)
 
-    assert res is True
+        assert res is True
 
 
 def test_is_blocked_task_multiple_input_no_data():
-    dn_0 = Config.configure_data_node("input_0", default_data="THIS")
-    dn_1 = Config.configure_data_node("input_1")
-    out = Config.configure_data_node("output_dn")
-    t_config = Config.configure_task("the_task", nothing, [dn_0, dn_1], [out])
-    sc_conf = Config.configure_scenario("scenario", [t_config])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
+    with patch("sys.argv", ["prog"]):
+        dn_0 = Config.configure_data_node("input_0", default_data="THIS")
+        dn_1 = Config.configure_data_node("input_1")
+        out = Config.configure_data_node("output_dn")
+        t_config = Config.configure_task("the_task", nothing, [dn_0, dn_1], [out])
+        sc_conf = Config.configure_scenario("scenario", [t_config])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
 
-    res = orchestrator._is_blocked(scenario.the_task)
+        res = orchestrator._is_blocked(scenario.the_task)
 
-    assert res is True
+        assert res is True
 
 
 def test_is_not_blocked_job_single_input():
-    inp = Config.configure_data_node("inp", default_data="DEFAULT")
-    t = Config.configure_task("the_task", nothing, [inp], [])
-    sc_conf = Config.configure_scenario("scenario", [t])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    job = _JobManagerFactory._build_manager()._create(scenario.the_task, [nothing], "s_id", "e_id")
+    with patch("sys.argv", ["prog"]):
+        inp = Config.configure_data_node("inp", default_data="DEFAULT")
+        t = Config.configure_task("the_task", nothing, [inp], [])
+        sc_conf = Config.configure_scenario("scenario", [t])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        job = _JobManagerFactory._build_manager()._create(scenario.the_task, [nothing], "s_id", "e_id")
 
-    res = orchestrator._is_blocked(job)
+        res = orchestrator._is_blocked(job)
 
-    assert res is False
+        assert res is False
 
 
 def test_is_not_blocked_job_multiple_input_and_output():
-    in_0 = Config.configure_data_node("in_0", default_data="THIS")
-    in_1 = Config.configure_data_node("in_1", default_data="IS")
-    out = Config.configure_data_node("output_dn")
-    t = Config.configure_task("the_task", nothing, [in_0, in_1], [out])
-    sc_conf = Config.configure_scenario("scenario", [t])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    job = _JobManagerFactory._build_manager()._create(scenario.the_task, [nothing], "s_id", "e_id")
+    with patch("sys.argv", ["prog"]):
+        in_0 = Config.configure_data_node("in_0", default_data="THIS")
+        in_1 = Config.configure_data_node("in_1", default_data="IS")
+        out = Config.configure_data_node("output_dn")
+        t = Config.configure_task("the_task", nothing, [in_0, in_1], [out])
+        sc_conf = Config.configure_scenario("scenario", [t])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        job = _JobManagerFactory._build_manager()._create(scenario.the_task, [nothing], "s_id", "e_id")
 
-    res = orchestrator._is_blocked(job)
+        res = orchestrator._is_blocked(job)
 
-    assert res is False
+        assert res is False
 
 
 def test_is_blocked_job_single_input_no_data():
-    inp = Config.configure_data_node("inp")
-    t = Config.configure_task("the_task", nothing, [inp], [])
-    sc_conf = Config.configure_scenario("scenario", [t])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    job = _JobManagerFactory._build_manager()._create(scenario.the_task, [nothing], "s_id", "e_id")
+    with patch("sys.argv", ["prog"]):
+        inp = Config.configure_data_node("inp")
+        t = Config.configure_task("the_task", nothing, [inp], [])
+        sc_conf = Config.configure_scenario("scenario", [t])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        job = _JobManagerFactory._build_manager()._create(scenario.the_task, [nothing], "s_id", "e_id")
 
-    res = orchestrator._is_blocked(job)
+        res = orchestrator._is_blocked(job)
 
-    assert res is True
+        assert res is True
 
 
 def test_is_blocked_job_single_input_edit_in_progress():
-    input_dn_cfg = Config.configure_data_node("inp", default_data="foo")
-    task_cfg = Config.configure_task("the_task", nothing, [input_dn_cfg])
-    sc_conf = Config.configure_scenario("scenario", [task_cfg])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    scenario.inp.lock_edit()
-    job = _JobManagerFactory._build_manager()._create(scenario.the_task, [nothing], "s_id", "e_id")
+    with patch("sys.argv", ["prog"]):
+        input_dn_cfg = Config.configure_data_node("inp", default_data="foo")
+        task_cfg = Config.configure_task("the_task", nothing, [input_dn_cfg])
+        sc_conf = Config.configure_scenario("scenario", [task_cfg])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        scenario.inp.lock_edit()
+        job = _JobManagerFactory._build_manager()._create(scenario.the_task, [nothing], "s_id", "e_id")
 
-    res = orchestrator._is_blocked(job)
+        res = orchestrator._is_blocked(job)
 
-    assert res is True
+        assert res is True
 
 
 def test_is_blocked_job_multiple_input_no_data():
-    dn_0 = Config.configure_data_node("in_0", default_data="THIS")
-    dn_1 = Config.configure_data_node("in_1", default_data="IS")
-    dn_2 = Config.configure_data_node("in_2")
-    out = Config.configure_data_node("output_dn")
-    t = Config.configure_task("the_task", nothing, [dn_0, dn_1, dn_2], [out])
-    sc_conf = Config.configure_scenario("scenario", [t])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    job = _JobManagerFactory._build_manager()._create(scenario.the_task, [nothing], "s_id", "e_id")
-
-    res = orchestrator._is_blocked(job)
-
-    assert res is True
+    with patch("sys.argv", ["prog"]):
+        dn_0 = Config.configure_data_node("in_0", default_data="THIS")
+        dn_1 = Config.configure_data_node("in_1", default_data="IS")
+        dn_2 = Config.configure_data_node("in_2")
+        out = Config.configure_data_node("output_dn")
+        t = Config.configure_task("the_task", nothing, [dn_0, dn_1, dn_2], [out])
+        sc_conf = Config.configure_scenario("scenario", [t])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        job = _JobManagerFactory._build_manager()._create(scenario.the_task, [nothing], "s_id", "e_id")
+
+        res = orchestrator._is_blocked(job)
+
+        assert res is True

tests/core/_orchestrator/test_orchestrator__lock_dn_output_and_create_job.py

@@ -8,6 +8,7 @@
 # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 # an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
+from unittest.mock import patch
 
 from taipy.config import Config
 from taipy.core import taipy
@@ -20,75 +21,79 @@ def nothing(*args, **kwargs):
 
 
 def test_lock_dn_and_create_job():
-    t = Config.configure_task("no_output", nothing, [], [])
-    sc_conf = Config.configure_scenario("scenario", [t])
-    scenario = taipy.create_scenario(sc_conf)
-    task = scenario.no_output
-    s_id = "submit_id"
-    entity_id = "scenario_id"
-    cbs = None
-    force = False
-
-    job = _OrchestratorFactory._build_orchestrator()._lock_dn_output_and_create_job(task, s_id, entity_id, cbs, force)
-
-    assert job.submit_id == s_id
-    assert job.submit_entity_id == entity_id
-    assert job.task == task
-    assert not job.force
-    assert len(job._subscribers) == 1
-    assert job._subscribers[0] == _Orchestrator._on_status_change
-    assert len(taipy.get_jobs()) == 1
+    with patch("sys.argv", ["prog"]):
+        t = Config.configure_task("no_output", nothing, [], [])
+        sc_conf = Config.configure_scenario("scenario", [t])
+        scenario = taipy.create_scenario(sc_conf)
+        task = scenario.no_output
+        s_id = "submit_id"
+        entity_id = "scenario_id"
+        cbs = None
+        force = False
+
+        job = _OrchestratorFactory._build_orchestrator()._lock_dn_output_and_create_job(task, s_id, entity_id, cbs, force)
+
+        assert job.submit_id == s_id
+        assert job.submit_entity_id == entity_id
+        assert job.task == task
+        assert not job.force
+        assert len(job._subscribers) == 1
+        assert job._subscribers[0] == _Orchestrator._on_status_change
+        assert len(taipy.get_jobs()) == 1
 
 
 def test_lock_dn_and_create_job_with_callback_and_force():
-    t = Config.configure_task("no_output", nothing, [], [])
-    sc_conf = Config.configure_scenario("scenario", [t])
-    scenario = taipy.create_scenario(sc_conf)
-    task = scenario.no_output
-    s_id = "submit_id"
-    entity_id = "scenario_id"
-    cbs = [nothing]
-    force = True
-
-    job = _OrchestratorFactory._build_orchestrator()._lock_dn_output_and_create_job(task, s_id, entity_id, cbs, force)
-
-    assert job.submit_id == s_id
-    assert job.submit_entity_id == entity_id
-    assert job.task == task
-    assert job.force
-    assert len(job._subscribers) == 2
-    assert job._subscribers[0] == nothing
-    assert job._subscribers[1] == _Orchestrator._on_status_change
-    assert len(taipy.get_jobs()) == 1
+    with patch("sys.argv", ["prog"]):
+        t = Config.configure_task("no_output", nothing, [], [])
+        sc_conf = Config.configure_scenario("scenario", [t])
+        scenario = taipy.create_scenario(sc_conf)
+        task = scenario.no_output
+        s_id = "submit_id"
+        entity_id = "scenario_id"
+        cbs = [nothing]
+        force = True
+
+        job = _OrchestratorFactory._build_orchestrator()._lock_dn_output_and_create_job(task, s_id, entity_id, cbs, force)
+
+        assert job.submit_id == s_id
+        assert job.submit_entity_id == entity_id
+        assert job.task == task
+        assert job.force
+        assert len(job._subscribers) == 2
+        assert job._subscribers[0] == nothing
+        assert job._subscribers[1] == _Orchestrator._on_status_change
+        assert len(taipy.get_jobs()) == 1
 
 
 def test_lock_dn_and_create_job_one_output():
-    dn = Config.configure_data_node("output_dn")
-    t = Config.configure_task("one_output", nothing, [], [dn])
-    sc_conf = Config.configure_scenario("scenario", [t])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    orchestrator._lock_dn_output_and_create_job(scenario.one_output, "submit_id", "scenario_id")
+    with patch("sys.argv", ["prog"]):
+        dn = Config.configure_data_node("output_dn")
+        t = Config.configure_task("one_output", nothing, [], [dn])
+        sc_conf = Config.configure_scenario("scenario", [t])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        orchestrator._lock_dn_output_and_create_job(scenario.one_output, "submit_id", "scenario_id")
 
-    assert scenario.output_dn.edit_in_progress
+        assert scenario.output_dn.edit_in_progress
 
 
 def test_lock_dn_and_create_job_multiple_outputs_one_input():
-    dn_0 = Config.configure_data_node("input_0", default_data=0)
-    dn_1 = Config.configure_data_node("output_1")
-    dn_2 = Config.configure_data_node("output_2")
-    dn_3 = Config.configure_data_node("output_3")
-    t = Config.configure_task("one_output", nothing, [dn_0], [dn_1, dn_2, dn_3])
-    sc_conf = Config.configure_scenario("scenario", [t])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    orchestrator._lock_dn_output_and_create_job(scenario.one_output, "submit_id", "scenario_id")
-
-    assert not scenario.input_0.edit_in_progress
-    assert scenario.input_0.is_ready_for_reading
-    assert scenario.output_1.edit_in_progress
-    assert not scenario.output_1.is_ready_for_reading
-    assert scenario.output_2.edit_in_progress
-    assert not scenario.output_2.is_ready_for_reading
-    assert scenario.output_3.edit_in_progress
-    assert not scenario.output_3.is_ready_for_reading
+    with patch("sys.argv", ["prog"]):
+        dn_0 = Config.configure_data_node("input_0", default_data=0)
+        dn_1 = Config.configure_data_node("output_1")
+        dn_2 = Config.configure_data_node("output_2")
+        dn_3 = Config.configure_data_node("output_3")
+        t = Config.configure_task("one_output", nothing, [dn_0], [dn_1, dn_2, dn_3])
+        sc_conf = Config.configure_scenario("scenario", [t])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        orchestrator._lock_dn_output_and_create_job(scenario.one_output, "submit_id", "scenario_id")
+
+        assert not scenario.input_0.edit_in_progress
+        assert scenario.input_0.is_ready_for_reading
+        assert scenario.output_1.edit_in_progress
+        assert not scenario.output_1.is_ready_for_reading
+        assert scenario.output_2.edit_in_progress
+        assert not scenario.output_2.is_ready_for_reading
+        assert scenario.output_3.edit_in_progress
+        assert not scenario.output_3.is_ready_for_reading

tests/core/_orchestrator/test_orchestrator__on_status_change.py

@@ -9,6 +9,7 @@
 # an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 from unittest import mock
+from unittest.mock import patch
 
 import taipy
 from taipy import Job, JobId, Status
@@ -141,24 +142,25 @@ def test_on_status_change_on_skipped_job():
 
 
 def test_on_status_change_on_failed_job():
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    scenario = create_scenario()
-    j1 = create_job_from_task("j1", scenario.t1)
-    j1.status = Status.FAILED
-    j2 = create_job_from_task("j2", scenario.t2)
-    j2.status = Status.BLOCKED
-    j3 = create_job_from_task("j3", scenario.t3)
-    j3.status = Status.BLOCKED
-    orchestrator.blocked_jobs.append(j2)
-    orchestrator.blocked_jobs.append(j3)
-
-    orchestrator._on_status_change(j1)
-
-    # Assert that when the status is skipped, the unblock jobs mechanism is executed
-    assert j1.is_failed()
-    assert j2 not in orchestrator.blocked_jobs
-    assert j2.is_abandoned()
-    assert j3 in orchestrator.blocked_jobs
-    assert j3.is_blocked()
-    assert len(orchestrator.blocked_jobs) == 1
-    assert orchestrator.jobs_to_run.qsize() == 0
+    with patch("sys.argv", ["prog"]):
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        scenario = create_scenario()
+        j1 = create_job_from_task("j1", scenario.t1)
+        j1.status = Status.FAILED
+        j2 = create_job_from_task("j2", scenario.t2)
+        j2.status = Status.BLOCKED
+        j3 = create_job_from_task("j3", scenario.t3)
+        j3.status = Status.BLOCKED
+        orchestrator.blocked_jobs.append(j2)
+        orchestrator.blocked_jobs.append(j3)
+
+        orchestrator._on_status_change(j1)
+
+        # Assert that when the status is skipped, the unblock jobs mechanism is executed
+        assert j1.is_failed()
+        assert j2 not in orchestrator.blocked_jobs
+        assert j2.is_abandoned()
+        assert j3 in orchestrator.blocked_jobs
+        assert j3.is_blocked()
+        assert len(orchestrator.blocked_jobs) == 1
+        assert orchestrator.jobs_to_run.qsize() == 0

tests/core/_orchestrator/test_orchestrator__orchestrate_job_to_run_or_block.py

@@ -8,6 +8,8 @@
 # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 # an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
+from unittest.mock import patch
+
 from taipy import Status
 from taipy.config import Config
 from taipy.core import taipy
@@ -20,56 +22,59 @@ def nothing(*args, **kwargs):
 
 
 def test_orchestrate_job_to_run_or_block_single_blocked_job():
-    inp = Config.configure_data_node("inp")  # No default data
-    t = Config.configure_task("the_task", nothing, [inp], [])
-    sc_conf = Config.configure_scenario("scenario", [t])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    job = _JobManagerFactory._build_manager()._create(scenario.the_task, [nothing], "s_id", "e_id")
+    with patch("sys.argv", ["prog"]):
+        inp = Config.configure_data_node("inp")  # No default data
+        t = Config.configure_task("the_task", nothing, [inp], [])
+        sc_conf = Config.configure_scenario("scenario", [t])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        job = _JobManagerFactory._build_manager()._create(scenario.the_task, [nothing], "s_id", "e_id")
 
-    orchestrator._orchestrate_job_to_run_or_block([job])
+        orchestrator._orchestrate_job_to_run_or_block([job])
 
-    assert len(orchestrator.blocked_jobs) == 1
-    assert job.status == Status.BLOCKED
-    assert orchestrator.jobs_to_run.empty()
+        assert len(orchestrator.blocked_jobs) == 1
+        assert job.status == Status.BLOCKED
+        assert orchestrator.jobs_to_run.empty()
 
 
 def test_orchestrate_job_to_run_or_block_single_pending_job():
-    inp = Config.configure_data_node("inp", default_data=1)  # Has default data
-    t = Config.configure_task("my_task", nothing, [inp], [])
-    sc_conf = Config.configure_scenario("scenario", [t])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    job = _JobManagerFactory._build_manager()._create(scenario.my_task, [nothing], "s_id", "e_id")
+    with patch("sys.argv", ["prog"]):
+        inp = Config.configure_data_node("inp", default_data=1)  # Has default data
+        t = Config.configure_task("my_task", nothing, [inp], [])
+        sc_conf = Config.configure_scenario("scenario", [t])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        job = _JobManagerFactory._build_manager()._create(scenario.my_task, [nothing], "s_id", "e_id")
 
-    orchestrator._orchestrate_job_to_run_or_block([job])
+        orchestrator._orchestrate_job_to_run_or_block([job])
 
-    assert len(orchestrator.blocked_jobs) == 0
-    assert job.status == Status.PENDING
-    assert orchestrator.jobs_to_run.qsize() == 1
+        assert len(orchestrator.blocked_jobs) == 0
+        assert job.status == Status.PENDING
+        assert orchestrator.jobs_to_run.qsize() == 1
 
 
 def test_orchestrate_job_to_run_or_block_multiple_jobs():
-    input = Config.configure_data_node("input_dn", default_data=1)  # Has default data
-    intermediate = Config.configure_data_node("intermediate")  # Has default data
-    output = Config.configure_data_node("output_dn")  # Has default data
-    t1 = Config.configure_task("my_task_1", nothing, [input], [])
-    t2 = Config.configure_task("my_task_2", nothing, [], [intermediate])
-    t3 = Config.configure_task("my_task_3", nothing, [intermediate], [output])
-    sc_conf = Config.configure_scenario("scenario", [t1, t2, t3])
-    scenario = taipy.create_scenario(sc_conf)
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    job_1 = _JobManagerFactory._build_manager()._create(scenario.my_task_1, [nothing], "s_id", "e_id")
-    job_2 = _JobManagerFactory._build_manager()._create(scenario.my_task_2, [nothing], "s_id", "e_id")
-    job_3 = _JobManagerFactory._build_manager()._create(scenario.my_task_3, [nothing], "s_id", "e_id")
-
-    orchestrator._orchestrate_job_to_run_or_block([job_1, job_2, job_3])
-
-    assert orchestrator.jobs_to_run.qsize() == 2
-    assert job_1.status == Status.PENDING
-    assert job_2.status == Status.PENDING
-    assert len(orchestrator.blocked_jobs) == 1
-    assert job_3.status == Status.BLOCKED
+    with patch("sys.argv", ["prog"]):
+        input = Config.configure_data_node("input_dn", default_data=1)  # Has default data
+        intermediate = Config.configure_data_node("intermediate")  # Has default data
+        output = Config.configure_data_node("output_dn")  # Has default data
+        t1 = Config.configure_task("my_task_1", nothing, [input], [])
+        t2 = Config.configure_task("my_task_2", nothing, [], [intermediate])
+        t3 = Config.configure_task("my_task_3", nothing, [intermediate], [output])
+        sc_conf = Config.configure_scenario("scenario", [t1, t2, t3])
+        scenario = taipy.create_scenario(sc_conf)
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        job_1 = _JobManagerFactory._build_manager()._create(scenario.my_task_1, [nothing], "s_id", "e_id")
+        job_2 = _JobManagerFactory._build_manager()._create(scenario.my_task_2, [nothing], "s_id", "e_id")
+        job_3 = _JobManagerFactory._build_manager()._create(scenario.my_task_3, [nothing], "s_id", "e_id")
+
+        orchestrator._orchestrate_job_to_run_or_block([job_1, job_2, job_3])
+
+        assert orchestrator.jobs_to_run.qsize() == 2
+        assert job_1.status == Status.PENDING
+        assert job_2.status == Status.PENDING
+        assert len(orchestrator.blocked_jobs) == 1
+        assert job_3.status == Status.BLOCKED
 
 
 def test_orchestrate_job_to_run_or_block__no_job_doesnot_raise_error():

tests/core/_orchestrator/test_orchestrator__submit.py

@@ -10,6 +10,7 @@
 # specific language governing permissions and limitations under the License.
 from datetime import datetime, timedelta
 from unittest import mock
+from unittest.mock import patch
 
 import freezegun
 import pytest
@@ -49,436 +50,443 @@ def create_scenario():
 
 
 def test_submit_scenario_development_mode():
-    scenario = create_scenario()
-    scenario.dn_0.write(0)  # input data is made ready
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-
-    submit_time = datetime.now() + timedelta(seconds=1)  # +1 to ensure the edit time of dn_0 is before the submit time
-    with freezegun.freeze_time(submit_time):
-        submission = orchestrator.submit(
-            scenario, no_of_retry=10, log=True, log_file="file_path"
-        )  # scenario is executed directly in development mode
-        jobs = submission.jobs
-
-    # data nodes should have been written (except the input dn_0)
-    assert scenario.dn_0.last_edit_date < submit_time
-    assert scenario.dn_1.last_edit_date == submit_time
-    assert scenario.dn_2.last_edit_date == submit_time
-    assert scenario.dn_3.last_edit_date == submit_time
-
-    # jobs are created in a specific order and are correct
-    assert len(jobs) == 4
-    # t1
-    job_1 = jobs[0]
-    assert job_1.task == scenario.t_1
-    assert not job_1.force
-    assert job_1.is_completed()
-    assert job_1.submit_entity_id == scenario.id
-    assert job_1.creation_date == submit_time
-    assert job_1.stacktrace == []
-    assert len(job_1._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_1._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_1._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    # t2 or t2_bis
-    job_2 = jobs[1]
-    assert job_2.task == scenario.t_2 or job_2.task == scenario.t_2bis
-    assert not job_2.force
-    assert job_2.is_completed()
-    assert job_2.submit_entity_id == scenario.id
-    assert job_2.creation_date == submit_time
-    assert job_2.stacktrace == []
-    assert len(job_2._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_2._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_2._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    # t2_bis or t2
-    job_2bis = jobs[2]
-    assert job_2bis.task == scenario.t_2bis or job_2bis.task == scenario.t_2
-    assert job_2bis.is_completed()
-    assert not job_2bis.force
-    assert job_2bis.submit_entity_id == scenario.id
-    assert job_2bis.creation_date == submit_time
-    assert len(job_2bis._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_2bis._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_2bis._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    assert job_2bis.stacktrace == []
-    # t3
-    job_3 = jobs[3]
-    assert job_3.task == scenario.t_3
-    assert not job_3.force
-    assert job_3.is_completed()
-    assert job_3.submit_entity_id == scenario.id
-    assert job_3.creation_date == submit_time
-    assert len(job_3._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_3._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_3._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    assert job_3.stacktrace == []
-
-    assert job_1.submit_id == job_2.submit_id == job_2bis.submit_id == job_3.submit_id
-
-    # submission is created and correct
-    assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
-    submission = _SubmissionManagerFactory._build_manager()._get(job_1.submit_id)
-    assert submission.submission_status == SubmissionStatus.COMPLETED
-    assert submission.jobs == jobs
-    assert submission.creation_date == submit_time
-    assert submission.entity_id == scenario.id
-    assert submission.entity_type == "SCENARIO"
-    assert submission.entity_config_id == "scenario_cfg"
-    assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
-
-    # orchestrator state is correct
-    assert len(orchestrator.blocked_jobs) == 0
-    assert orchestrator.jobs_to_run.qsize() == 0
+    with patch("sys.argv", ["prog"]):
+        scenario = create_scenario()
+        scenario.dn_0.write(0)  # input data is made ready
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+
+        submit_time = datetime.now() + timedelta(seconds=1)  # +1 to ensure the edit time of dn_0 is before the submit time
+        with freezegun.freeze_time(submit_time):
+            submission = orchestrator.submit(
+                scenario, no_of_retry=10, log=True, log_file="file_path"
+            )  # scenario is executed directly in development mode
+            jobs = submission.jobs
+
+        # data nodes should have been written (except the input dn_0)
+        assert scenario.dn_0.last_edit_date < submit_time
+        assert scenario.dn_1.last_edit_date == submit_time
+        assert scenario.dn_2.last_edit_date == submit_time
+        assert scenario.dn_3.last_edit_date == submit_time
+
+        # jobs are created in a specific order and are correct
+        assert len(jobs) == 4
+        # t1
+        job_1 = jobs[0]
+        assert job_1.task == scenario.t_1
+        assert not job_1.force
+        assert job_1.is_completed()
+        assert job_1.submit_entity_id == scenario.id
+        assert job_1.creation_date == submit_time
+        assert job_1.stacktrace == []
+        assert len(job_1._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_1._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_1._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        # t2 or t2_bis
+        job_2 = jobs[1]
+        assert job_2.task == scenario.t_2 or job_2.task == scenario.t_2bis
+        assert not job_2.force
+        assert job_2.is_completed()
+        assert job_2.submit_entity_id == scenario.id
+        assert job_2.creation_date == submit_time
+        assert job_2.stacktrace == []
+        assert len(job_2._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_2._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_2._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        # t2_bis or t2
+        job_2bis = jobs[2]
+        assert job_2bis.task == scenario.t_2bis or job_2bis.task == scenario.t_2
+        assert job_2bis.is_completed()
+        assert not job_2bis.force
+        assert job_2bis.submit_entity_id == scenario.id
+        assert job_2bis.creation_date == submit_time
+        assert len(job_2bis._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_2bis._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_2bis._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        assert job_2bis.stacktrace == []
+        # t3
+        job_3 = jobs[3]
+        assert job_3.task == scenario.t_3
+        assert not job_3.force
+        assert job_3.is_completed()
+        assert job_3.submit_entity_id == scenario.id
+        assert job_3.creation_date == submit_time
+        assert len(job_3._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_3._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_3._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        assert job_3.stacktrace == []
+
+        assert job_1.submit_id == job_2.submit_id == job_2bis.submit_id == job_3.submit_id
+
+        # submission is created and correct
+        assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
+        submission = _SubmissionManagerFactory._build_manager()._get(job_1.submit_id)
+        assert submission.submission_status == SubmissionStatus.COMPLETED
+        assert submission.jobs == jobs
+        assert submission.creation_date == submit_time
+        assert submission.entity_id == scenario.id
+        assert submission.entity_type == "SCENARIO"
+        assert submission.entity_config_id == "scenario_cfg"
+        assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
+
+        # orchestrator state is correct
+        assert len(orchestrator.blocked_jobs) == 0
+        assert orchestrator.jobs_to_run.qsize() == 0
 
 
 def test_submit_scenario_development_mode_blocked_jobs():
-    scenario = create_scenario()  # input data is not ready
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-
-    s_time = datetime.now() + timedelta(seconds=1)  # +1 to ensure the scenario creation is before the submit time
-    with freezegun.freeze_time(s_time):
-        submission = orchestrator.submit(
-            scenario, no_of_retry=10, log=True, log_file="file_path"
-        )  # first task is blocked because input is not ready
-        jobs = submission.jobs
-
-    # dn should be locked for edition
-    assert scenario.dn_2.edit_in_progress
-    assert scenario.dn_2.edit_in_progress
-    assert scenario.dn_3.edit_in_progress
-
-    # jobs are created in a specific order and are correct
-    assert len(jobs) == 4
-    # t1
-    job_1 = jobs[0]
-    assert job_1.task == scenario.t_1
-    assert not job_1.force
-    assert job_1.is_blocked()
-    assert job_1.submit_entity_id == scenario.id
-    assert job_1.creation_date == s_time
-    assert job_1.stacktrace == []
-    assert len(job_1._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_1._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_1._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    # t2 or t2_bis
-    job_2 = jobs[1]
-    assert job_2.task == scenario.t_2 or job_2.task == scenario.t_2bis
-    assert not job_2.force
-    assert job_2.is_blocked()
-    assert job_2.submit_entity_id == scenario.id
-    assert job_2.creation_date == s_time
-    assert job_2.stacktrace == []
-    assert len(job_2._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_2._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_2._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    # t2_bis or t2
-    job_2bis = jobs[2]
-    assert job_2bis.task == scenario.t_2bis or job_2bis.task == scenario.t_2
-    assert job_2bis.is_blocked()
-    assert job_2bis.submit_entity_id == scenario.id
-    assert not job_2bis.force
-    assert job_2bis.creation_date == s_time
-    assert len(job_2bis._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_2bis._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_2bis._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    assert job_2bis.stacktrace == []
-    # t3
-    job_3 = jobs[3]
-    assert job_3.task == scenario.t_3
-    assert not job_3.force
-    assert job_3.is_blocked()
-    assert job_3.submit_entity_id == scenario.id
-    assert job_3.creation_date == s_time
-    assert job_3.stacktrace == []
-    assert len(job_3._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_3._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_3._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-
-    # Same submit_id
-    assert job_1.submit_id == job_2.submit_id == job_2bis.submit_id == job_3.submit_id
-
-    # submission is created and correct
-    assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
-    submission = _SubmissionManagerFactory._build_manager()._get(job_1.submit_id)
-    assert submission.submission_status == SubmissionStatus.BLOCKED
-    assert submission.jobs == jobs
-    assert submission.creation_date == s_time
-    assert submission.entity_id == scenario.id
-    assert submission.entity_type == "SCENARIO"
-    assert submission.entity_config_id == "scenario_cfg"
-    assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
-
-    # orchestrator state is correct
-    assert len(orchestrator.blocked_jobs) == 4
-    assert orchestrator.jobs_to_run.qsize() == 0
+    with patch("sys.argv", ["prog"]):
+        scenario = create_scenario()  # input data is not ready
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+
+        s_time = datetime.now() + timedelta(seconds=1)  # +1 to ensure the scenario creation is before the submit time
+        with freezegun.freeze_time(s_time):
+            submission = orchestrator.submit(
+                scenario, no_of_retry=10, log=True, log_file="file_path"
+            )  # first task is blocked because input is not ready
+            jobs = submission.jobs
+
+        # dn should be locked for edition
+        assert scenario.dn_2.edit_in_progress
+        assert scenario.dn_2.edit_in_progress
+        assert scenario.dn_3.edit_in_progress
+
+        # jobs are created in a specific order and are correct
+        assert len(jobs) == 4
+        # t1
+        job_1 = jobs[0]
+        assert job_1.task == scenario.t_1
+        assert not job_1.force
+        assert job_1.is_blocked()
+        assert job_1.submit_entity_id == scenario.id
+        assert job_1.creation_date == s_time
+        assert job_1.stacktrace == []
+        assert len(job_1._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_1._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_1._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        # t2 or t2_bis
+        job_2 = jobs[1]
+        assert job_2.task == scenario.t_2 or job_2.task == scenario.t_2bis
+        assert not job_2.force
+        assert job_2.is_blocked()
+        assert job_2.submit_entity_id == scenario.id
+        assert job_2.creation_date == s_time
+        assert job_2.stacktrace == []
+        assert len(job_2._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_2._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_2._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        # t2_bis or t2
+        job_2bis = jobs[2]
+        assert job_2bis.task == scenario.t_2bis or job_2bis.task == scenario.t_2
+        assert job_2bis.is_blocked()
+        assert job_2bis.submit_entity_id == scenario.id
+        assert not job_2bis.force
+        assert job_2bis.creation_date == s_time
+        assert len(job_2bis._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_2bis._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_2bis._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        assert job_2bis.stacktrace == []
+        # t3
+        job_3 = jobs[3]
+        assert job_3.task == scenario.t_3
+        assert not job_3.force
+        assert job_3.is_blocked()
+        assert job_3.submit_entity_id == scenario.id
+        assert job_3.creation_date == s_time
+        assert job_3.stacktrace == []
+        assert len(job_3._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_3._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_3._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+
+        # Same submit_id
+        assert job_1.submit_id == job_2.submit_id == job_2bis.submit_id == job_3.submit_id
+
+        # submission is created and correct
+        assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
+        submission = _SubmissionManagerFactory._build_manager()._get(job_1.submit_id)
+        assert submission.submission_status == SubmissionStatus.BLOCKED
+        assert submission.jobs == jobs
+        assert submission.creation_date == s_time
+        assert submission.entity_id == scenario.id
+        assert submission.entity_type == "SCENARIO"
+        assert submission.entity_config_id == "scenario_cfg"
+        assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
+
+        # orchestrator state is correct
+        assert len(orchestrator.blocked_jobs) == 4
+        assert orchestrator.jobs_to_run.qsize() == 0
 
 
 @pytest.mark.standalone
 def test_submit_scenario_standalone_mode():
-    Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE)
-    sc = create_scenario()
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-    sc.dn_0.write(0)  # input data is made ready
-    submit_time = datetime.now() + timedelta(seconds=1)  # +1 to ensure the edit time of dn_0 is before the submit time
-    with freezegun.freeze_time(submit_time):
-        submission = orchestrator.submit(
-            sc, no_of_retry=10, log=True, log_file="file_path"
-        )  # No dispatcher running. sc is not executed.
-        jobs = submission.jobs
-
-    # task output should be locked for edition
-    assert sc.dn_1.edit_in_progress
-    assert sc.dn_2.edit_in_progress
-    assert sc.dn_3.edit_in_progress
-
-    # jobs are created in a specific order and are correct
-    assert len(jobs) == 4
-    # t1
-    job_1 = jobs[0]
-    assert job_1.task == sc.t_1
-    assert not job_1.force
-    assert job_1.is_pending()
-    assert job_1.creation_date == submit_time
-    assert job_1.submit_entity_id == sc.id
-    assert len(job_1._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_1._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_1._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    assert job_1.stacktrace == []
-    # t2 or t2_bis
-    job_2 = jobs[1]
-    assert job_2.task == sc.t_2 or job_2.task == sc.t_2bis
-    assert job_2.is_blocked()
-    assert not job_2.force
-    assert job_2.submit_entity_id == sc.id
-    assert job_2.creation_date == submit_time
-    assert job_2.stacktrace == []
-    assert len(job_2._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_2._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    assert job_2._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    # t2_bis or t2
-    job_2bis = jobs[2]
-    assert job_2bis.task == sc.t_2bis or job_2bis.task == sc.t_2
-    assert job_2bis.is_blocked()
-    assert not job_2bis.force
-    assert job_2bis.submit_entity_id == sc.id
-    assert len(job_2bis._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_2bis._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    assert job_2bis._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_2bis.creation_date == submit_time
-    assert job_2bis.stacktrace == []
-    # t3
-    job_3 = jobs[3]
-    assert job_3.task == sc.t_3
-    assert not job_3.force
-    assert job_3.is_blocked()
-    assert job_3.submit_entity_id == sc.id
-    assert len(job_3._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_3._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    assert job_3._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_3.creation_date == submit_time
-    assert job_3.stacktrace == []
-
-    assert job_1.submit_id == job_2.submit_id == job_2bis.submit_id == job_3.submit_id
-
-    # submission is created and correct
-    assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
-    submission = _SubmissionManagerFactory._build_manager()._get(job_1.submit_id)
-    assert submission.submission_status == SubmissionStatus.PENDING
-    assert submission.jobs == jobs
-    assert submission.creation_date == submit_time
-    assert submission.entity_id == sc.id
-    assert submission.entity_type == "SCENARIO"
-    assert submission.entity_config_id == "scenario_cfg"
-    assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
-
-    # orchestrator state is correct
-    assert len(orchestrator.blocked_jobs) == 3
-    assert orchestrator.jobs_to_run.qsize() == 1
+    with patch("sys.argv", ["prog"]):
+        Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE)
+        sc = create_scenario()
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+        sc.dn_0.write(0)  # input data is made ready
+        submit_time = datetime.now() + timedelta(seconds=1)  # +1 to ensure the edit time of dn_0 is before the submit time
+        with freezegun.freeze_time(submit_time):
+            submission = orchestrator.submit(
+                sc, no_of_retry=10, log=True, log_file="file_path"
+            )  # No dispatcher running. sc is not executed.
+            jobs = submission.jobs
+
+        # task output should be locked for edition
+        assert sc.dn_1.edit_in_progress
+        assert sc.dn_2.edit_in_progress
+        assert sc.dn_3.edit_in_progress
+
+        # jobs are created in a specific order and are correct
+        assert len(jobs) == 4
+        # t1
+        job_1 = jobs[0]
+        assert job_1.task == sc.t_1
+        assert not job_1.force
+        assert job_1.is_pending()
+        assert job_1.creation_date == submit_time
+        assert job_1.submit_entity_id == sc.id
+        assert len(job_1._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_1._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_1._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        assert job_1.stacktrace == []
+        # t2 or t2_bis
+        job_2 = jobs[1]
+        assert job_2.task == sc.t_2 or job_2.task == sc.t_2bis
+        assert job_2.is_blocked()
+        assert not job_2.force
+        assert job_2.submit_entity_id == sc.id
+        assert job_2.creation_date == submit_time
+        assert job_2.stacktrace == []
+        assert len(job_2._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_2._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        assert job_2._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        # t2_bis or t2
+        job_2bis = jobs[2]
+        assert job_2bis.task == sc.t_2bis or job_2bis.task == sc.t_2
+        assert job_2bis.is_blocked()
+        assert not job_2bis.force
+        assert job_2bis.submit_entity_id == sc.id
+        assert len(job_2bis._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_2bis._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        assert job_2bis._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_2bis.creation_date == submit_time
+        assert job_2bis.stacktrace == []
+        # t3
+        job_3 = jobs[3]
+        assert job_3.task == sc.t_3
+        assert not job_3.force
+        assert job_3.is_blocked()
+        assert job_3.submit_entity_id == sc.id
+        assert len(job_3._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_3._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        assert job_3._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_3.creation_date == submit_time
+        assert job_3.stacktrace == []
+
+        assert job_1.submit_id == job_2.submit_id == job_2bis.submit_id == job_3.submit_id
+
+        # submission is created and correct
+        assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
+        submission = _SubmissionManagerFactory._build_manager()._get(job_1.submit_id)
+        assert submission.submission_status == SubmissionStatus.PENDING
+        assert submission.jobs == jobs
+        assert submission.creation_date == submit_time
+        assert submission.entity_id == sc.id
+        assert submission.entity_type == "SCENARIO"
+        assert submission.entity_config_id == "scenario_cfg"
+        assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
+
+        # orchestrator state is correct
+        assert len(orchestrator.blocked_jobs) == 3
+        assert orchestrator.jobs_to_run.qsize() == 1
 
 
 def test_submit_scenario_with_callbacks_and_force_and_wait():
-    Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE)
-    scenario = create_scenario()
-    orchestrator = _OrchestratorFactory._build_orchestrator()
+    with patch("sys.argv", ["prog"]):
+        Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE)
+        scenario = create_scenario()
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+
+        with mock.patch("taipy.core._orchestrator._orchestrator._Orchestrator._wait_until_job_finished") as mck:
+            submission = orchestrator.submit(scenario, callbacks=[nothing], force=True, wait=True, timeout=5)
+            jobs = submission.jobs
+
+            # jobs are created in a specific order and are correct
+            assert len(jobs) == 4
+            assert len(jobs[0]._subscribers) == 3  # nothing, _update_submission_status, and _on_status_change
+            assert jobs[0]._subscribers[0].__code__ == nothing.__code__
+            assert jobs[0]._subscribers[1].__code__ == _Orchestrator._update_submission_status.__code__
+            assert jobs[0]._subscribers[2].__code__ == _Orchestrator._on_status_change.__code__
+            assert len(jobs[1]._subscribers) == 3  # nothing, _update_submission_status, and _on_status_change
+            assert jobs[1]._subscribers[0].__code__ == nothing.__code__
+            assert jobs[1]._subscribers[1].__code__ == _Orchestrator._update_submission_status.__code__
+            assert jobs[1]._subscribers[2].__code__ == _Orchestrator._on_status_change.__code__
+            assert len(jobs[2]._subscribers) == 3  # nothing, _update_submission_status, and _on_status_change
+            assert jobs[2]._subscribers[0].__code__ == nothing.__code__
+            assert jobs[2]._subscribers[1].__code__ == _Orchestrator._update_submission_status.__code__
+            assert jobs[2]._subscribers[2].__code__ == _Orchestrator._on_status_change.__code__
+            mck.assert_called_once_with(jobs, timeout=5)
 
-    with mock.patch("taipy.core._orchestrator._orchestrator._Orchestrator._wait_until_job_finished") as mck:
-        submission = orchestrator.submit(scenario, callbacks=[nothing], force=True, wait=True, timeout=5)
-        jobs = submission.jobs
 
-        # jobs are created in a specific order and are correct
-        assert len(jobs) == 4
-        assert len(jobs[0]._subscribers) == 3  # nothing, _update_submission_status, and _on_status_change
-        assert jobs[0]._subscribers[0].__code__ == nothing.__code__
-        assert jobs[0]._subscribers[1].__code__ == _Orchestrator._update_submission_status.__code__
-        assert jobs[0]._subscribers[2].__code__ == _Orchestrator._on_status_change.__code__
-        assert len(jobs[1]._subscribers) == 3  # nothing, _update_submission_status, and _on_status_change
-        assert jobs[1]._subscribers[0].__code__ == nothing.__code__
-        assert jobs[1]._subscribers[1].__code__ == _Orchestrator._update_submission_status.__code__
-        assert jobs[1]._subscribers[2].__code__ == _Orchestrator._on_status_change.__code__
-        assert len(jobs[2]._subscribers) == 3  # nothing, _update_submission_status, and _on_status_change
-        assert jobs[2]._subscribers[0].__code__ == nothing.__code__
-        assert jobs[2]._subscribers[1].__code__ == _Orchestrator._update_submission_status.__code__
-        assert jobs[2]._subscribers[2].__code__ == _Orchestrator._on_status_change.__code__
-        mck.assert_called_once_with(jobs, timeout=5)
+def test_submit_sequence_development_mode():
+    with patch("sys.argv", ["prog"]):
+        sce = create_scenario()
+        sce.add_sequence("seq", [sce.t_1, sce.t_2, sce.t_3])
+        seq = sce.sequences["seq"]
+        sce.dn_0.write(0)  # input data is made ready
 
+        orchestrator = _OrchestratorFactory._build_orchestrator()
 
-def test_submit_sequence_development_mode():
-    sce = create_scenario()
-    sce.add_sequence("seq", [sce.t_1, sce.t_2, sce.t_3])
-    seq = sce.sequences["seq"]
-    sce.dn_0.write(0)  # input data is made ready
-
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-
-    submit_time = datetime.now() + timedelta(seconds=1)  # +1 to ensure the edit time of dn_0 is before the submit time
-    with freezegun.freeze_time(submit_time):
-        submission = orchestrator.submit(
-            seq, no_of_retry=10, log=True, log_file="file_path"
-        )  # sequence is executed directly in development mode
-        jobs = submission.jobs
-
-    # data nodes should have been written (except the input dn_0)
-    assert sce.dn_0.last_edit_date < submit_time
-    assert sce.dn_1.last_edit_date == submit_time == sce.dn_2.last_edit_date == sce.dn_3.last_edit_date
-
-    # jobs are created in a specific order and are correct
-    assert len(jobs) == 3
-    # t1
-    job_1 = jobs[0]
-    assert job_1.task == sce.t_1
-    assert not job_1.force
-    assert job_1.is_completed()
-    assert job_1.submit_entity_id == seq.id
-    assert job_1.creation_date == submit_time
-    assert job_1.stacktrace == []
-    assert len(job_1._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_1._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_1._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    # t2
-    job_2 = jobs[1]
-    assert job_2.task == sce.t_2
-    assert not job_2.force
-    assert job_2.is_completed()
-    assert job_2.submit_entity_id == seq.id
-    assert job_2.creation_date == submit_time
-    assert job_2.stacktrace == []
-    assert len(job_2._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_2._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_2._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    # t3
-    job_3 = jobs[2]
-    assert job_3.task == sce.t_3
-    assert not job_3.force
-    assert job_3.is_completed()
-    assert job_3.submit_entity_id == seq.id
-    assert len(job_3._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_3._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job_3._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    assert job_3.creation_date == submit_time
-    assert job_3.stacktrace == []
-
-    assert job_1.submit_id == job_2.submit_id == job_3.submit_id
-
-    # submission is created and correct
-    assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
-    submission = _SubmissionManagerFactory._build_manager()._get(job_1.submit_id)
-    assert submission.entity_type == "SEQUENCE"
-    assert submission.submission_status == SubmissionStatus.COMPLETED
-    assert submission.entity_config_id is None
-    assert submission.jobs == jobs
-    assert submission.creation_date == submit_time
-    assert submission.entity_id == seq.id
-    assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
-
-    # orchestrator state is correct
-    assert len(orchestrator.blocked_jobs) == 0
-    assert orchestrator.jobs_to_run.qsize() == 0
+        submit_time = datetime.now() + timedelta(seconds=1)  # +1 to ensure the edit time of dn_0 is before the submit time
+        with freezegun.freeze_time(submit_time):
+            submission = orchestrator.submit(
+                seq, no_of_retry=10, log=True, log_file="file_path"
+            )  # sequence is executed directly in development mode
+            jobs = submission.jobs
+
+        # data nodes should have been written (except the input dn_0)
+        assert sce.dn_0.last_edit_date < submit_time
+        assert sce.dn_1.last_edit_date == submit_time == sce.dn_2.last_edit_date == sce.dn_3.last_edit_date
+
+        # jobs are created in a specific order and are correct
+        assert len(jobs) == 3
+        # t1
+        job_1 = jobs[0]
+        assert job_1.task == sce.t_1
+        assert not job_1.force
+        assert job_1.is_completed()
+        assert job_1.submit_entity_id == seq.id
+        assert job_1.creation_date == submit_time
+        assert job_1.stacktrace == []
+        assert len(job_1._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_1._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_1._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        # t2
+        job_2 = jobs[1]
+        assert job_2.task == sce.t_2
+        assert not job_2.force
+        assert job_2.is_completed()
+        assert job_2.submit_entity_id == seq.id
+        assert job_2.creation_date == submit_time
+        assert job_2.stacktrace == []
+        assert len(job_2._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_2._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_2._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        # t3
+        job_3 = jobs[2]
+        assert job_3.task == sce.t_3
+        assert not job_3.force
+        assert job_3.is_completed()
+        assert job_3.submit_entity_id == seq.id
+        assert len(job_3._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_3._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job_3._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        assert job_3.creation_date == submit_time
+        assert job_3.stacktrace == []
+
+        assert job_1.submit_id == job_2.submit_id == job_3.submit_id
+
+        # submission is created and correct
+        assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
+        submission = _SubmissionManagerFactory._build_manager()._get(job_1.submit_id)
+        assert submission.entity_type == "SEQUENCE"
+        assert submission.submission_status == SubmissionStatus.COMPLETED
+        assert submission.entity_config_id is None
+        assert submission.jobs == jobs
+        assert submission.creation_date == submit_time
+        assert submission.entity_id == seq.id
+        assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
+
+        # orchestrator state is correct
+        assert len(orchestrator.blocked_jobs) == 0
+        assert orchestrator.jobs_to_run.qsize() == 0
 
 
 @pytest.mark.standalone
 def test_submit_sequence_standalone_mode():
-    Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE)
-    scenario = create_scenario()
-    scenario.dn_0.write(0)  # input data is made ready
-    scenario.add_sequence("seq", [scenario.t_1, scenario.t_2, scenario.t_3])
-    sequence = scenario.sequences["seq"]
-
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-
-    submit_time = datetime.now() + timedelta(seconds=1)  # +1 to ensure the edit time of dn_0 is before the submit time
-    with freezegun.freeze_time(submit_time):
-        submission = orchestrator.submit(
-            sequence, no_of_retry=10, log=True, log_file="file_path"
-        )  # sequence is executed directly in development mode
-        jobs = submission.jobs
-
-    assert scenario.dn_1.edit_in_progress
-    assert scenario.dn_2.edit_in_progress
-    assert scenario.dn_3.edit_in_progress
-
-    # jobs are created in a specific order and are correct
-    assert len(jobs) == 3
-    # t1
-    job_1 = jobs[0]
-    assert job_1.task == scenario.t_1
-    assert not job_1.force
-    assert job_1.is_pending()
-    assert job_1.creation_date == submit_time
-    assert job_1.submit_entity_id == sequence.id
-    assert job_1.stacktrace == []
-    assert len(job_1._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    # t2
-    job_2 = jobs[1]
-    assert job_2.task == scenario.t_2
-    assert not job_2.force
-    assert job_2.is_blocked()
-    assert job_2.submit_entity_id == sequence.id
-    assert job_2.creation_date == submit_time
-    assert job_2.stacktrace == []
-    assert len(job_2._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    # t3
-    job_3 = jobs[2]
-    assert job_3.task == scenario.t_3
-    assert not job_3.force
-    assert job_3.is_blocked()
-    assert job_3.creation_date == submit_time
-    assert job_3.submit_entity_id == sequence.id
-    assert len(job_3._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
-    assert job_3.stacktrace == []
-
-    assert job_1.submit_id == job_2.submit_id == job_3.submit_id
-
-    # submission is created and correct
-    assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
-    submission = _SubmissionManagerFactory._build_manager()._get(job_1.submit_id)
-    assert submission.submission_status == SubmissionStatus.PENDING
-    assert submission.entity_type == "SEQUENCE"
-    assert submission.entity_config_id is None
-    assert submission.jobs == jobs
-    assert submission.creation_date == submit_time
-    assert submission.entity_id == sequence.id
-    assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
-
-    # orchestrator state is correct
-    assert len(orchestrator.blocked_jobs) == 2
-    assert orchestrator.jobs_to_run.qsize() == 1
+    with patch("sys.argv", ["prog"]):
+        Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE)
+        scenario = create_scenario()
+        scenario.dn_0.write(0)  # input data is made ready
+        scenario.add_sequence("seq", [scenario.t_1, scenario.t_2, scenario.t_3])
+        sequence = scenario.sequences["seq"]
+
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+
+        submit_time = datetime.now() + timedelta(seconds=1)  # +1 to ensure the edit time of dn_0 is before the submit time
+        with freezegun.freeze_time(submit_time):
+            submission = orchestrator.submit(
+                sequence, no_of_retry=10, log=True, log_file="file_path"
+            )  # sequence is executed directly in development mode
+            jobs = submission.jobs
+
+        assert scenario.dn_1.edit_in_progress
+        assert scenario.dn_2.edit_in_progress
+        assert scenario.dn_3.edit_in_progress
+
+        # jobs are created in a specific order and are correct
+        assert len(jobs) == 3
+        # t1
+        job_1 = jobs[0]
+        assert job_1.task == scenario.t_1
+        assert not job_1.force
+        assert job_1.is_pending()
+        assert job_1.creation_date == submit_time
+        assert job_1.submit_entity_id == sequence.id
+        assert job_1.stacktrace == []
+        assert len(job_1._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        # t2
+        job_2 = jobs[1]
+        assert job_2.task == scenario.t_2
+        assert not job_2.force
+        assert job_2.is_blocked()
+        assert job_2.submit_entity_id == sequence.id
+        assert job_2.creation_date == submit_time
+        assert job_2.stacktrace == []
+        assert len(job_2._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        # t3
+        job_3 = jobs[2]
+        assert job_3.task == scenario.t_3
+        assert not job_3.force
+        assert job_3.is_blocked()
+        assert job_3.creation_date == submit_time
+        assert job_3.submit_entity_id == sequence.id
+        assert len(job_3._subscribers) == 2  # _Orchestrator._update_submission_status and orchestrator._on_status_change
+        assert job_3.stacktrace == []
+
+        assert job_1.submit_id == job_2.submit_id == job_3.submit_id
+
+        # submission is created and correct
+        assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
+        submission = _SubmissionManagerFactory._build_manager()._get(job_1.submit_id)
+        assert submission.submission_status == SubmissionStatus.PENDING
+        assert submission.entity_type == "SEQUENCE"
+        assert submission.entity_config_id is None
+        assert submission.jobs == jobs
+        assert submission.creation_date == submit_time
+        assert submission.entity_id == sequence.id
+        assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
+
+        # orchestrator state is correct
+        assert len(orchestrator.blocked_jobs) == 2
+        assert orchestrator.jobs_to_run.qsize() == 1
 
 
 @pytest.mark.standalone
 def test_submit_sequence_with_callbacks_and_force_and_wait():
-    Config.configure_job_executions(mode="standalone")
-    scenario = create_scenario()
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-
-    with mock.patch("taipy.core._orchestrator._orchestrator._Orchestrator._wait_until_job_finished") as mck:
-        jobs = orchestrator.submit(scenario, callbacks=[nothing], force=True, wait=True, timeout=5).jobs
-        mck.assert_called_once_with(jobs, timeout=5)
-
-    # jobs are created in a specific order and are correct
-    assert len(jobs) == 4
-    assert len(jobs[0]._subscribers) == 3  # nothing, _update_submission_status, and _on_status_change
-    assert len(jobs[1]._subscribers) == 3  # nothing, _update_submission_status, and _on_status_change
-    assert len(jobs[2]._subscribers) == 3  # nothing, _update_submission_status, and _on_status_change
+    with patch("sys.argv", ["prog"]):
+        Config.configure_job_executions(mode="standalone")
+        scenario = create_scenario()
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+
+        with mock.patch("taipy.core._orchestrator._orchestrator._Orchestrator._wait_until_job_finished") as mck:
+            jobs = orchestrator.submit(scenario, callbacks=[nothing], force=True, wait=True, timeout=5).jobs
+            mck.assert_called_once_with(jobs, timeout=5)
+
+        # jobs are created in a specific order and are correct
+        assert len(jobs) == 4
+        assert len(jobs[0]._subscribers) == 3  # nothing, _update_submission_status, and _on_status_change
+        assert len(jobs[1]._subscribers) == 3  # nothing, _update_submission_status, and _on_status_change
+        assert len(jobs[2]._subscribers) == 3  # nothing, _update_submission_status, and _on_status_change
 
 
 def test_submit_submittable_generate_unique_submit_id():

tests/core/_orchestrator/test_orchestrator__submit_task.py

@@ -10,6 +10,7 @@
 # specific language governing permissions and limitations under the License.
 from datetime import datetime
 from unittest import mock
+from unittest.mock import patch
 
 import freezegun
 import pytest
@@ -43,196 +44,201 @@ def create_scenario():
 
 
 def test_submit_task_development_mode():
-    scenario = create_scenario()
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-
-    submit_time = datetime.now()
-    with freezegun.freeze_time(submit_time):
-        submission = orchestrator.submit_task(
-            scenario.t1, no_of_retry=10, log=True, log_file="file_path"
-        )  # t1 is executed directly in development mode
-        job = submission.jobs[0]
-
-    # task output should have been written
-    assert scenario.dn_1.last_edit_date == submit_time
-
-    # job exists and is correct
-    assert job.task == scenario.t1
-    assert not job.force
-    assert job.is_completed()
-    assert job.submit_entity_id == scenario.t1.id
-    assert job.creation_date == submit_time
-    assert job.stacktrace == []
-    assert len(job._subscribers) == 2  # _Orchestrator._update_submission_status and _Orchestrator._on_status_change
-    assert job._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-
-    # submission is created and correct
-    assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
-    submission = _SubmissionManagerFactory._build_manager()._get(submission)
-    assert submission.creation_date == submit_time
-    assert submission.submission_status == SubmissionStatus.COMPLETED
-    assert submission.jobs == [job]
-    assert submission.entity_id == scenario.t1.id
-    assert submission.entity_type == "TASK"
-    assert submission.entity_config_id == "t1"
-    assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
-
-    # orchestrator state is correct
-    assert len(orchestrator.blocked_jobs) == 0
-    assert orchestrator.jobs_to_run.qsize() == 0
+    with patch("sys.argv", ["prog"]):
+        scenario = create_scenario()
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+
+        submit_time = datetime.now()
+        with freezegun.freeze_time(submit_time):
+            submission = orchestrator.submit_task(
+                scenario.t1, no_of_retry=10, log=True, log_file="file_path"
+            )  # t1 is executed directly in development mode
+            job = submission.jobs[0]
+
+        # task output should have been written
+        assert scenario.dn_1.last_edit_date == submit_time
+
+        # job exists and is correct
+        assert job.task == scenario.t1
+        assert not job.force
+        assert job.is_completed()
+        assert job.submit_entity_id == scenario.t1.id
+        assert job.creation_date == submit_time
+        assert job.stacktrace == []
+        assert len(job._subscribers) == 2  # _Orchestrator._update_submission_status and _Orchestrator._on_status_change
+        assert job._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+
+        # submission is created and correct
+        assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
+        submission = _SubmissionManagerFactory._build_manager()._get(submission)
+        assert submission.creation_date == submit_time
+        assert submission.submission_status == SubmissionStatus.COMPLETED
+        assert submission.jobs == [job]
+        assert submission.entity_id == scenario.t1.id
+        assert submission.entity_type == "TASK"
+        assert submission.entity_config_id == "t1"
+        assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
+
+        # orchestrator state is correct
+        assert len(orchestrator.blocked_jobs) == 0
+        assert orchestrator.jobs_to_run.qsize() == 0
 
 
 def test_submit_task_development_mode_blocked_job():
-    scenario = create_scenario()
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-
-    submit_time = datetime.now()
-    with freezegun.freeze_time(submit_time):
-        submission = orchestrator.submit_task(
-            scenario.t2, no_of_retry=10, log=True, log_file="file_path"
-        )  # t1 is executed directly in development mode
-        job = submission.jobs[0]
-
-    # task output should have been written
-    assert scenario.dn_2.edit_in_progress
-
-    # job exists and is correct
-    assert job.task == scenario.t2
-    assert not job.force
-    assert job.is_blocked()  # input data is not ready
-    assert job.submit_entity_id == scenario.t2.id
-    assert job.creation_date == submit_time
-    assert len(job._subscribers) == 2  # _Orchestrator._update_submission_status and _Orchestrator._on_status_change
-    assert job._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    assert job.stacktrace == []
-
-    # submission is created and correct
-    assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
-    submission = _SubmissionManagerFactory._build_manager()._get(submission)
-    assert submission.submission_status == SubmissionStatus.BLOCKED
-    assert submission.creation_date == submit_time
-    assert submission.jobs == [job]
-    assert submission.entity_id == scenario.t2.id
-    assert submission.entity_type == "TASK"
-    assert submission.entity_config_id == "t2"
-    assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
-
-    # orchestrator state is correct
-    assert len(orchestrator.blocked_jobs) == 1
-    assert orchestrator.jobs_to_run.qsize() == 0
+    with patch("sys.argv", ["prog"]):
+        scenario = create_scenario()
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+
+        submit_time = datetime.now()
+        with freezegun.freeze_time(submit_time):
+            submission = orchestrator.submit_task(
+                scenario.t2, no_of_retry=10, log=True, log_file="file_path"
+            )  # t1 is executed directly in development mode
+            job = submission.jobs[0]
+
+        # task output should have been written
+        assert scenario.dn_2.edit_in_progress
+
+        # job exists and is correct
+        assert job.task == scenario.t2
+        assert not job.force
+        assert job.is_blocked()  # input data is not ready
+        assert job.submit_entity_id == scenario.t2.id
+        assert job.creation_date == submit_time
+        assert len(job._subscribers) == 2  # _Orchestrator._update_submission_status and _Orchestrator._on_status_change
+        assert job._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        assert job.stacktrace == []
+
+        # submission is created and correct
+        assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
+        submission = _SubmissionManagerFactory._build_manager()._get(submission)
+        assert submission.submission_status == SubmissionStatus.BLOCKED
+        assert submission.creation_date == submit_time
+        assert submission.jobs == [job]
+        assert submission.entity_id == scenario.t2.id
+        assert submission.entity_type == "TASK"
+        assert submission.entity_config_id == "t2"
+        assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
+
+        # orchestrator state is correct
+        assert len(orchestrator.blocked_jobs) == 1
+        assert orchestrator.jobs_to_run.qsize() == 0
 
 
 @pytest.mark.standalone
 def test_submit_task_standalone_mode():
-    Config.configure_job_executions(mode="standalone")
-    sc = create_scenario()
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-
-    submit_time = datetime.now()
-    with freezegun.freeze_time(submit_time):
-        submission = orchestrator.submit_task(
-            sc.t1, no_of_retry=10, log=True, log_file="file_path"
-        )  # No dispatcher running. t1 is not executed in standalone mode.
-        job = submission.jobs[0]
-
-    # task output should NOT have been written
-    assert sc.dn_1.last_edit_date is None
-
-    # task output should be locked for edition
-    assert sc.dn_1.edit_in_progress
-
-    # job exists and is correct
-    assert job.creation_date == submit_time
-    assert job.task == sc.t1
-    assert not job.force
-    assert job.is_pending()
-    assert job.submit_entity_id == sc.t1.id
-    assert len(job._subscribers) == 2  # _Orchestrator._update_submission_status and _Orchestrator._on_status_change
-    assert job._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    assert job.stacktrace == []
-
-    # submission is created and correct
-    assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
-    submission = _SubmissionManagerFactory._build_manager()._get(submission)
-    assert submission.creation_date == submit_time
-    assert submission.submission_status == SubmissionStatus.PENDING
-    assert submission.jobs == [job]
-    assert submission.entity_id == sc.t1.id
-    assert submission.entity_type == "TASK"
-    assert submission.entity_config_id == "t1"
-    assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
-
-    # orchestrator state is correct
-    assert len(orchestrator.blocked_jobs) == 0
-    assert orchestrator.jobs_to_run.qsize() == 1
+    with patch("sys.argv", ["prog"]):
+        Config.configure_job_executions(mode="standalone")
+        sc = create_scenario()
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+
+        submit_time = datetime.now()
+        with freezegun.freeze_time(submit_time):
+            submission = orchestrator.submit_task(
+                sc.t1, no_of_retry=10, log=True, log_file="file_path"
+            )  # No dispatcher running. t1 is not executed in standalone mode.
+            job = submission.jobs[0]
+
+        # task output should NOT have been written
+        assert sc.dn_1.last_edit_date is None
+
+        # task output should be locked for edition
+        assert sc.dn_1.edit_in_progress
+
+        # job exists and is correct
+        assert job.creation_date == submit_time
+        assert job.task == sc.t1
+        assert not job.force
+        assert job.is_pending()
+        assert job.submit_entity_id == sc.t1.id
+        assert len(job._subscribers) == 2  # _Orchestrator._update_submission_status and _Orchestrator._on_status_change
+        assert job._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        assert job.stacktrace == []
+
+        # submission is created and correct
+        assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
+        submission = _SubmissionManagerFactory._build_manager()._get(submission)
+        assert submission.creation_date == submit_time
+        assert submission.submission_status == SubmissionStatus.PENDING
+        assert submission.jobs == [job]
+        assert submission.entity_id == sc.t1.id
+        assert submission.entity_type == "TASK"
+        assert submission.entity_config_id == "t1"
+        assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
+
+        # orchestrator state is correct
+        assert len(orchestrator.blocked_jobs) == 0
+        assert orchestrator.jobs_to_run.qsize() == 1
 
 
 @pytest.mark.standalone
 def test_submit_task_standalone_mode_blocked_job():
-    Config.configure_job_executions(mode="standalone")
-    sc = create_scenario()
-    orchestrator = _OrchestratorFactory._build_orchestrator()
-
-    submit_time = datetime.now()
-    with freezegun.freeze_time(submit_time):
-        submission = orchestrator.submit_task(
-            sc.t2, no_of_retry=10, log=True, log_file="file_path"
-        )  # No dispatcher running. t2 is not executed in standalone mode.
-        job = submission.jobs[0]
-
-    # task output should NOT have been written
-    assert sc.dn_2.last_edit_date is None
-
-    # task output should be locked for edition
-    assert sc.dn_2.edit_in_progress
-
-    # job exists and is correct
-    assert job.creation_date == submit_time
-    assert job.task == sc.t2
-    assert not job.force
-    assert job.is_blocked()  # input data is not ready
-    assert job.stacktrace == []
-    assert len(job._subscribers) == 2  # _Orchestrator._update_submission_status and _Orchestrator._on_status_change
-    assert job._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
-    assert job._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
-    assert job.submit_entity_id == sc.t2.id
-
-    # submission is created and correct
-    assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
-    submission = _SubmissionManagerFactory._build_manager()._get(submission)
-    assert submission.creation_date == submit_time
-    assert submission.submission_status == SubmissionStatus.BLOCKED
-    assert submission.jobs == [job]
-    assert submission.entity_id == sc.t2.id
-    assert submission.entity_type == "TASK"
-    assert submission.entity_config_id == "t2"
-    assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
-
-    # orchestrator state is correct
-    assert len(orchestrator.blocked_jobs) == 1
-    assert orchestrator.jobs_to_run.qsize() == 0
+    with patch("sys.argv", ["prog"]):
+        Config.configure_job_executions(mode="standalone")
+        sc = create_scenario()
+        orchestrator = _OrchestratorFactory._build_orchestrator()
 
+        submit_time = datetime.now()
+        with freezegun.freeze_time(submit_time):
+            submission = orchestrator.submit_task(
+                sc.t2, no_of_retry=10, log=True, log_file="file_path"
+            )  # No dispatcher running. t2 is not executed in standalone mode.
+            job = submission.jobs[0]
 
-@pytest.mark.standalone
-def test_submit_task_with_callbacks_and_force_and_wait():
-    Config.configure_job_executions(mode="standalone")
-    scenario = create_scenario()
-    orchestrator = _OrchestratorFactory._build_orchestrator()
+        # task output should NOT have been written
+        assert sc.dn_2.last_edit_date is None
 
-    with mock.patch("taipy.core._orchestrator._orchestrator._Orchestrator._wait_until_job_finished") as mck:
-        job = orchestrator.submit_task(scenario.t1, callbacks=[nothing], force=True, wait=True, timeout=2).jobs[0]
+        # task output should be locked for edition
+        assert sc.dn_2.edit_in_progress
 
         # job exists and is correct
-        assert job.task == scenario.t1
-        assert job.force
-        assert (
-            len(job._subscribers) == 3
-        )  # nothing, _Orchestrator._update_submission_status, and _Orchestrator._on_status_change
-        assert job._subscribers[0].__code__ == nothing.__code__
-        assert job._subscribers[1].__code__ == _Orchestrator._update_submission_status.__code__
-        assert job._subscribers[2].__code__ == _Orchestrator._on_status_change.__code__
-
-        mck.assert_called_once_with(job, timeout=2)
+        assert job.creation_date == submit_time
+        assert job.task == sc.t2
+        assert not job.force
+        assert job.is_blocked()  # input data is not ready
+        assert job.stacktrace == []
+        assert len(job._subscribers) == 2  # _Orchestrator._update_submission_status and _Orchestrator._on_status_change
+        assert job._subscribers[0].__code__ == _Orchestrator._update_submission_status.__code__
+        assert job._subscribers[1].__code__ == _Orchestrator._on_status_change.__code__
+        assert job.submit_entity_id == sc.t2.id
+
+        # submission is created and correct
+        assert len(_SubmissionManagerFactory._build_manager()._get_all()) == 1
+        submission = _SubmissionManagerFactory._build_manager()._get(submission)
+        assert submission.creation_date == submit_time
+        assert submission.submission_status == SubmissionStatus.BLOCKED
+        assert submission.jobs == [job]
+        assert submission.entity_id == sc.t2.id
+        assert submission.entity_type == "TASK"
+        assert submission.entity_config_id == "t2"
+        assert submission.properties == {"no_of_retry": 10, "log": True, "log_file": "file_path"}
+
+        # orchestrator state is correct
+        assert len(orchestrator.blocked_jobs) == 1
+        assert orchestrator.jobs_to_run.qsize() == 0
+
+
+@pytest.mark.standalone
+def test_submit_task_with_callbacks_and_force_and_wait():
+    with patch("sys.argv", ["prog"]):
+        Config.configure_job_executions(mode="standalone")
+        scenario = create_scenario()
+        orchestrator = _OrchestratorFactory._build_orchestrator()
+
+        with mock.patch("taipy.core._orchestrator._orchestrator._Orchestrator._wait_until_job_finished") as mck:
+            job = orchestrator.submit_task(scenario.t1, callbacks=[nothing], force=True, wait=True, timeout=2).jobs[0]
+
+            # job exists and is correct
+            assert job.task == scenario.t1
+            assert job.force
+            assert (
+                len(job._subscribers) == 3
+            )  # nothing, _Orchestrator._update_submission_status, and _Orchestrator._on_status_change
+            assert job._subscribers[0].__code__ == nothing.__code__
+            assert job._subscribers[1].__code__ == _Orchestrator._update_submission_status.__code__
+            assert job._subscribers[2].__code__ == _Orchestrator._on_status_change.__code__
+
+            mck.assert_called_once_with(job, timeout=2)

tests/core/data/test_data_manager.py

@@ -10,6 +10,7 @@
 # specific language governing permissions and limitations under the License.
 import os
 import pathlib
+from unittest.mock import patch
 
 import pytest
 
@@ -514,72 +515,75 @@ class TestDataManager:
         assert not file_exists(generated_pickle_dn_3.path)
 
     def test_create_dn_from_loaded_config_no_scope(self):
-        file_config = NamedTemporaryFile(
-            """
-            [TAIPY]
+        with patch("sys.argv", ["prog"]):
+            file_config = NamedTemporaryFile(
+                """
+                [TAIPY]
 
-            [DATA_NODE.a]
-            default_data = "4:int"
+                [DATA_NODE.a]
+                default_data = "4:int"
 
-            [DATA_NODE.b]
+                [DATA_NODE.b]
 
-            [TASK.t]
-            function = "math.sqrt:function"
-            inputs = [ "a:SECTION",]
-            outputs = [ "b:SECTION",]
-            skippable = "False:bool"
+                [TASK.t]
+                function = "math.sqrt:function"
+                inputs = [ "a:SECTION",]
+                outputs = [ "b:SECTION",]
+                skippable = "False:bool"
 
-            [SCENARIO.s]
-            tasks = [ "t:SECTION",]
-            sequences.s_sequence = [ "t:SECTION",]
+                [SCENARIO.s]
+                tasks = [ "t:SECTION",]
+                sequences.s_sequence = [ "t:SECTION",]
 
-            [SCENARIO.s.comparators]
-            """
-        )
-        from taipy import core as tp
+                [SCENARIO.s.comparators]
+                """
+            )
+            from taipy import core as tp
 
-        Config.override(file_config.filename)
-        tp.create_scenario(Config.scenarios["s"])
-        tp.create_scenario(Config.scenarios["s"])
+            Config.override(file_config.filename)
+            tp.create_scenario(Config.scenarios["s"])
+            tp.create_scenario(Config.scenarios["s"])
 
-        assert len(tp.get_data_nodes()) == 4
+            assert len(tp.get_data_nodes()) == 4
 
     def test_create_dn_from_loaded_config_no_storage_type(self):
-        file_config = NamedTemporaryFile(
-            """
-            [TAIPY]
+        with patch("sys.argv", ["prog"]):
+            file_config = NamedTemporaryFile(
+                """
+                [TAIPY]
 
-            [DATA_NODE.input_dn]
-            scope = "SCENARIO:SCOPE"
-            default_data = "21:int"
+                [DATA_NODE.input_dn]
+                scope = "SCENARIO:SCOPE"
+                default_data = "21:int"
 
-            [DATA_NODE.output_dn]
-            storage_type = "in_memory"
-            scope = "SCENARIO:SCOPE"
+                [DATA_NODE.output_dn]
+                storage_type = "in_memory"
+                scope = "SCENARIO:SCOPE"
 
-            [TASK.double]
-            inputs = [ "input_dn:SECTION",]
-            function = "math.sqrt:function"
-            outputs = [ "output_dn:SECTION",]
-            skippable = "False:bool"
+                [TASK.double]
+                inputs = [ "input_dn:SECTION",]
+                function = "math.sqrt:function"
+                outputs = [ "output_dn:SECTION",]
+                skippable = "False:bool"
 
-            [SCENARIO.my_scenario]
-            tasks = [ "double:SECTION",]
-            sequences.my_sequence = [ "double:SECTION",]
+                [SCENARIO.my_scenario]
+                tasks = [ "double:SECTION",]
+                sequences.my_sequence = [ "double:SECTION",]
 
-            [SCENARIO.my_scenario.comparators]
-            """
-        )
-        from taipy import core as tp
+                [SCENARIO.my_scenario.comparators]
+                """
+            )
+            from taipy import core as tp
 
-        Config.override(file_config.filename)
-        scenario = tp.create_scenario(Config.scenarios["my_scenario"])
+            Config.override(file_config.filename)
+            scenario = tp.create_scenario(Config.scenarios["my_scenario"])
 
-        assert isinstance(scenario.input_dn, PickleDataNode)
-        assert isinstance(scenario.output_dn, InMemoryDataNode)
+            assert isinstance(scenario.input_dn, PickleDataNode)
+            assert isinstance(scenario.output_dn, InMemoryDataNode)
 
     def test_create_dn_from_loaded_config_modified_default_config(self):
-        file_config = NamedTemporaryFile(
+        with patch("sys.argv", ["prog"]):
+            file_config = NamedTemporaryFile(
             """
             [TAIPY]
 
@@ -604,14 +608,14 @@ class TestDataManager:
             [SCENARIO.my_scenario.comparators]
             """
         )
-        from taipy import core as tp
+            from taipy import core as tp
 
-        Config.set_default_data_node_configuration(storage_type="csv")
-        Config.override(file_config.filename)
-        scenario = tp.create_scenario(Config.scenarios["my_scenario"])
+            Config.set_default_data_node_configuration(storage_type="csv")
+            Config.override(file_config.filename)
+            scenario = tp.create_scenario(Config.scenarios["my_scenario"])
 
-        assert isinstance(scenario.input_dn, CSVDataNode)
-        assert isinstance(scenario.output_dn, InMemoryDataNode)
+            assert isinstance(scenario.input_dn, CSVDataNode)
+            assert isinstance(scenario.output_dn, InMemoryDataNode)
 
     def test_get_tasks_by_config_id(self):
         dn_config_1 = Config.configure_data_node("dn_1", scope=Scope.SCENARIO)

tests/core/data/test_data_node.py

@@ -13,6 +13,7 @@ import os
 from datetime import datetime, timedelta
 from time import sleep
 from unittest import mock
+from unittest.mock import patch
 
 import pytest
 
@@ -247,137 +248,140 @@ class TestDataNode:
         assert dn.is_valid is False
 
     def test_is_up_to_date(self, current_datetime):
-        dn_confg_1 = Config.configure_in_memory_data_node("dn_1")
-        dn_confg_2 = Config.configure_in_memory_data_node("dn_2")
-        dn_confg_3 = Config.configure_in_memory_data_node("dn_3", scope=Scope.GLOBAL)
-        task_config_1 = Config.configure_task("t1", print, [dn_confg_1], [dn_confg_2])
-        task_config_2 = Config.configure_task("t2", print, [dn_confg_2], [dn_confg_3])
-        scenario_config = Config.configure_scenario("sc", [task_config_1, task_config_2])
-
-        scenario_1 = tp.create_scenario(scenario_config)
-        assert len(_DataManager._get_all()) == 3
-
-        dn_1_1 = scenario_1.data_nodes["dn_1"]
-        dn_2_1 = scenario_1.data_nodes["dn_2"]
-        dn_3_1 = scenario_1.data_nodes["dn_3"]
-
-        assert dn_1_1.last_edit_date is None
-        assert dn_2_1.last_edit_date is None
-        assert dn_3_1.last_edit_date is None
-
-        dn_1_1.last_edit_date = current_datetime + timedelta(1)
-        dn_2_1.last_edit_date = current_datetime + timedelta(2)
-        dn_3_1.last_edit_date = current_datetime + timedelta(3)
-        assert dn_1_1.is_up_to_date
-        assert dn_2_1.is_up_to_date
-        assert dn_3_1.is_up_to_date
-
-        dn_2_1.last_edit_date = current_datetime + timedelta(4)
-        assert dn_1_1.is_up_to_date
-        assert dn_2_1.is_up_to_date
-        assert not dn_3_1.is_up_to_date
-
-        dn_1_1.last_edit_date = current_datetime + timedelta(5)
-        assert dn_1_1.is_up_to_date
-        assert not dn_2_1.is_up_to_date
-        assert not dn_3_1.is_up_to_date
-
-        dn_1_1.last_edit_date = current_datetime + timedelta(1)
-        dn_2_1.last_edit_date = current_datetime + timedelta(2)
-        dn_3_1.last_edit_date = current_datetime + timedelta(3)
+        with patch("sys.argv", ["prog"]):
+            dn_confg_1 = Config.configure_in_memory_data_node("dn_1")
+            dn_confg_2 = Config.configure_in_memory_data_node("dn_2")
+            dn_confg_3 = Config.configure_in_memory_data_node("dn_3", scope=Scope.GLOBAL)
+            task_config_1 = Config.configure_task("t1", print, [dn_confg_1], [dn_confg_2])
+            task_config_2 = Config.configure_task("t2", print, [dn_confg_2], [dn_confg_3])
+            scenario_config = Config.configure_scenario("sc", [task_config_1, task_config_2])
+
+            scenario_1 = tp.create_scenario(scenario_config)
+            assert len(_DataManager._get_all()) == 3
+
+            dn_1_1 = scenario_1.data_nodes["dn_1"]
+            dn_2_1 = scenario_1.data_nodes["dn_2"]
+            dn_3_1 = scenario_1.data_nodes["dn_3"]
+
+            assert dn_1_1.last_edit_date is None
+            assert dn_2_1.last_edit_date is None
+            assert dn_3_1.last_edit_date is None
+
+            dn_1_1.last_edit_date = current_datetime + timedelta(1)
+            dn_2_1.last_edit_date = current_datetime + timedelta(2)
+            dn_3_1.last_edit_date = current_datetime + timedelta(3)
+            assert dn_1_1.is_up_to_date
+            assert dn_2_1.is_up_to_date
+            assert dn_3_1.is_up_to_date
+
+            dn_2_1.last_edit_date = current_datetime + timedelta(4)
+            assert dn_1_1.is_up_to_date
+            assert dn_2_1.is_up_to_date
+            assert not dn_3_1.is_up_to_date
+
+            dn_1_1.last_edit_date = current_datetime + timedelta(5)
+            assert dn_1_1.is_up_to_date
+            assert not dn_2_1.is_up_to_date
+            assert not dn_3_1.is_up_to_date
+
+            dn_1_1.last_edit_date = current_datetime + timedelta(1)
+            dn_2_1.last_edit_date = current_datetime + timedelta(2)
+            dn_3_1.last_edit_date = current_datetime + timedelta(3)
 
     def test_is_up_to_date_across_scenarios(self, current_datetime):
-        dn_confg_1 = Config.configure_in_memory_data_node("dn_1", scope=Scope.SCENARIO)
-        dn_confg_2 = Config.configure_in_memory_data_node("dn_2", scope=Scope.SCENARIO)
-        dn_confg_3 = Config.configure_in_memory_data_node("dn_3", scope=Scope.GLOBAL)
-        task_config_1 = Config.configure_task("t1", print, [dn_confg_1], [dn_confg_2])
-        task_config_2 = Config.configure_task("t2", print, [dn_confg_2], [dn_confg_3])
-        scenario_config = Config.configure_scenario("sc", [task_config_1, task_config_2])
-
-        scenario_1 = tp.create_scenario(scenario_config)
-        scenario_2 = tp.create_scenario(scenario_config)
-        assert len(_DataManager._get_all()) == 5
-
-        dn_1_1 = scenario_1.data_nodes["dn_1"]
-        dn_2_1 = scenario_1.data_nodes["dn_2"]
-        dn_1_2 = scenario_2.data_nodes["dn_1"]
-        dn_2_2 = scenario_2.data_nodes["dn_2"]
-        dn_3 = scenario_1.data_nodes["dn_3"]
-        assert dn_3 == scenario_2.data_nodes["dn_3"]
-
-        assert dn_1_1.last_edit_date is None
-        assert dn_2_1.last_edit_date is None
-        assert dn_1_2.last_edit_date is None
-        assert dn_2_2.last_edit_date is None
-        assert dn_3.last_edit_date is None
-
-        dn_1_1.last_edit_date = current_datetime + timedelta(1)
-        dn_2_1.last_edit_date = current_datetime + timedelta(2)
-        dn_1_2.last_edit_date = current_datetime + timedelta(3)
-        dn_2_2.last_edit_date = current_datetime + timedelta(4)
-        dn_3.last_edit_date = current_datetime + timedelta(5)
-        assert dn_1_1.is_up_to_date
-        assert dn_2_1.is_up_to_date
-        assert dn_1_2.is_up_to_date
-        assert dn_2_2.is_up_to_date
-        assert dn_3.is_up_to_date
-
-        dn_2_1.last_edit_date = current_datetime + timedelta(6)
-        assert dn_1_1.is_up_to_date
-        assert dn_2_1.is_up_to_date
-        assert dn_1_2.is_up_to_date
-        assert dn_2_2.is_up_to_date
-        assert not dn_3.is_up_to_date
-
-        dn_2_1.last_edit_date = current_datetime + timedelta(2)
-        dn_2_2.last_edit_date = current_datetime + timedelta(6)
-        assert dn_1_1.is_up_to_date
-        assert dn_2_1.is_up_to_date
-        assert dn_1_2.is_up_to_date
-        assert dn_2_2.is_up_to_date
-        assert not dn_3.is_up_to_date
-
-        dn_2_2.last_edit_date = current_datetime + timedelta(4)
-        dn_1_1.last_edit_date = current_datetime + timedelta(6)
-        assert dn_1_1.is_up_to_date
-        assert not dn_2_1.is_up_to_date
-        assert dn_1_2.is_up_to_date
-        assert dn_2_2.is_up_to_date
-        assert not dn_3.is_up_to_date
-
-        dn_1_2.last_edit_date = current_datetime + timedelta(6)
-        assert dn_1_1.is_up_to_date
-        assert not dn_2_1.is_up_to_date
-        assert dn_1_2.is_up_to_date
-        assert not dn_2_2.is_up_to_date
-        assert not dn_3.is_up_to_date
+        with patch("sys.argv", ["prog"]):
+            dn_confg_1 = Config.configure_in_memory_data_node("dn_1", scope=Scope.SCENARIO)
+            dn_confg_2 = Config.configure_in_memory_data_node("dn_2", scope=Scope.SCENARIO)
+            dn_confg_3 = Config.configure_in_memory_data_node("dn_3", scope=Scope.GLOBAL)
+            task_config_1 = Config.configure_task("t1", print, [dn_confg_1], [dn_confg_2])
+            task_config_2 = Config.configure_task("t2", print, [dn_confg_2], [dn_confg_3])
+            scenario_config = Config.configure_scenario("sc", [task_config_1, task_config_2])
+
+            scenario_1 = tp.create_scenario(scenario_config)
+            scenario_2 = tp.create_scenario(scenario_config)
+            assert len(_DataManager._get_all()) == 5
+
+            dn_1_1 = scenario_1.data_nodes["dn_1"]
+            dn_2_1 = scenario_1.data_nodes["dn_2"]
+            dn_1_2 = scenario_2.data_nodes["dn_1"]
+            dn_2_2 = scenario_2.data_nodes["dn_2"]
+            dn_3 = scenario_1.data_nodes["dn_3"]
+            assert dn_3 == scenario_2.data_nodes["dn_3"]
+
+            assert dn_1_1.last_edit_date is None
+            assert dn_2_1.last_edit_date is None
+            assert dn_1_2.last_edit_date is None
+            assert dn_2_2.last_edit_date is None
+            assert dn_3.last_edit_date is None
+
+            dn_1_1.last_edit_date = current_datetime + timedelta(1)
+            dn_2_1.last_edit_date = current_datetime + timedelta(2)
+            dn_1_2.last_edit_date = current_datetime + timedelta(3)
+            dn_2_2.last_edit_date = current_datetime + timedelta(4)
+            dn_3.last_edit_date = current_datetime + timedelta(5)
+            assert dn_1_1.is_up_to_date
+            assert dn_2_1.is_up_to_date
+            assert dn_1_2.is_up_to_date
+            assert dn_2_2.is_up_to_date
+            assert dn_3.is_up_to_date
+
+            dn_2_1.last_edit_date = current_datetime + timedelta(6)
+            assert dn_1_1.is_up_to_date
+            assert dn_2_1.is_up_to_date
+            assert dn_1_2.is_up_to_date
+            assert dn_2_2.is_up_to_date
+            assert not dn_3.is_up_to_date
+
+            dn_2_1.last_edit_date = current_datetime + timedelta(2)
+            dn_2_2.last_edit_date = current_datetime + timedelta(6)
+            assert dn_1_1.is_up_to_date
+            assert dn_2_1.is_up_to_date
+            assert dn_1_2.is_up_to_date
+            assert dn_2_2.is_up_to_date
+            assert not dn_3.is_up_to_date
+
+            dn_2_2.last_edit_date = current_datetime + timedelta(4)
+            dn_1_1.last_edit_date = current_datetime + timedelta(6)
+            assert dn_1_1.is_up_to_date
+            assert not dn_2_1.is_up_to_date
+            assert dn_1_2.is_up_to_date
+            assert dn_2_2.is_up_to_date
+            assert not dn_3.is_up_to_date
+
+            dn_1_2.last_edit_date = current_datetime + timedelta(6)
+            assert dn_1_1.is_up_to_date
+            assert not dn_2_1.is_up_to_date
+            assert dn_1_2.is_up_to_date
+            assert not dn_2_2.is_up_to_date
+            assert not dn_3.is_up_to_date
 
     def test_do_not_recompute_data_node_valid_but_continue_sequence_execution(self):
-        a = Config.configure_data_node("A", "pickle", default_data="A")
-        b = Config.configure_data_node("B", "pickle")
-        c = Config.configure_data_node("C", "pickle")
-        d = Config.configure_data_node("D", "pickle")
-
-        task_a_b = Config.configure_task("task_a_b", funct_a_b, input=a, output=b, skippable=True)
-        task_b_c = Config.configure_task("task_b_c", funct_b_c, input=b, output=c)
-        task_b_d = Config.configure_task("task_b_d", funct_b_d, input=b, output=d)
-        scenario_cfg = Config.configure_scenario("scenario", [task_a_b, task_b_c, task_b_d])
-
-        scenario = tp.create_scenario(scenario_cfg)
-        scenario.submit()
-        assert scenario.A.read() == "A"
-        assert scenario.B.read() == "B"
-        assert scenario.C.read() == "C"
-        assert scenario.D.read() == "D"
-
-        scenario.submit()
-
-        assert len(tp.get_jobs()) == 6
-        jobs_and_status = [(job.task.config_id, job.status) for job in tp.get_jobs()]
-        assert ("task_a_b", tp.Status.COMPLETED) in jobs_and_status
-        assert ("task_a_b", tp.Status.SKIPPED) in jobs_and_status
-        assert ("task_b_c", tp.Status.COMPLETED) in jobs_and_status
-        assert ("task_b_d", tp.Status.COMPLETED) in jobs_and_status
+        with patch("sys.argv", ["prog"]):
+            a = Config.configure_data_node("A", "pickle", default_data="A")
+            b = Config.configure_data_node("B", "pickle")
+            c = Config.configure_data_node("C", "pickle")
+            d = Config.configure_data_node("D", "pickle")
+
+            task_a_b = Config.configure_task("task_a_b", funct_a_b, input=a, output=b, skippable=True)
+            task_b_c = Config.configure_task("task_b_c", funct_b_c, input=b, output=c)
+            task_b_d = Config.configure_task("task_b_d", funct_b_d, input=b, output=d)
+            scenario_cfg = Config.configure_scenario("scenario", [task_a_b, task_b_c, task_b_d])
+
+            scenario = tp.create_scenario(scenario_cfg)
+            scenario.submit()
+            assert scenario.A.read() == "A"
+            assert scenario.B.read() == "B"
+            assert scenario.C.read() == "C"
+            assert scenario.D.read() == "D"
+
+            scenario.submit()
+
+            assert len(tp.get_jobs()) == 6
+            jobs_and_status = [(job.task.config_id, job.status) for job in tp.get_jobs()]
+            assert ("task_a_b", tp.Status.COMPLETED) in jobs_and_status
+            assert ("task_a_b", tp.Status.SKIPPED) in jobs_and_status
+            assert ("task_b_c", tp.Status.COMPLETED) in jobs_and_status
+            assert ("task_b_d", tp.Status.COMPLETED) in jobs_and_status
 
     def test_data_node_update_after_writing(self):
         dn = FakeDataNode("foo")
@@ -716,12 +720,13 @@ class TestDataNode:
         assert dn.get_simple_label() == "a label"
 
     def test_change_data_node_name(self):
-        cgf = Config.configure_data_node("foo", scope=Scope.GLOBAL)
-        dn = tp.create_global_data_node(cgf)
+        with patch("sys.argv", ["prog"]):
+            cgf = Config.configure_data_node("foo", scope=Scope.GLOBAL)
+            dn = tp.create_global_data_node(cgf)
 
-        dn.name = "bar"
-        assert dn.name == "bar"
+            dn.name = "bar"
+            assert dn.name == "bar"
 
-        # This new syntax will be the only one allowed: https://github.com/Avaiga/taipy-core/issues/806
-        dn.properties["name"] = "baz"
-        assert dn.name == "baz"
+            # This new syntax will be the only one allowed: https://github.com/Avaiga/taipy-core/issues/806
+            dn.properties["name"] = "baz"
+            assert dn.name == "baz"

tests/core/notification/test_events_published.py

@@ -10,6 +10,7 @@
 # specific language governing permissions and limitations under the License.
 
 from queue import SimpleQueue
+from unittest.mock import patch
 
 from taipy.config import Config, Frequency
 from taipy.core import taipy as tp
@@ -102,141 +103,145 @@ def test_events_published_for_scenario_creation():
 
 
 def test_no_event_published_for_getting_scenario():
-    input_config = Config.configure_data_node("the_input")
-    output_config = Config.configure_data_node("the_output")
-    task_config = Config.configure_task("the_task", identity, input=input_config, output=output_config)
-    sc_config = Config.configure_scenario(
-        "the_scenario", task_configs=[task_config], frequency=Frequency.DAILY, sequences={"the_seq": [task_config]}
-    )
-    scenario = tp.create_scenario(sc_config)
+    with patch("sys.argv", ["prog"]):
+        input_config = Config.configure_data_node("the_input")
+        output_config = Config.configure_data_node("the_output")
+        task_config = Config.configure_task("the_task", identity, input=input_config, output=output_config)
+        sc_config = Config.configure_scenario(
+            "the_scenario", task_configs=[task_config], frequency=Frequency.DAILY, sequences={"the_seq": [task_config]}
+        )
+        scenario = tp.create_scenario(sc_config)
 
-    register_id_0, register_queue_0 = Notifier.register()
-    all_evts = RecordingConsumer(register_id_0, register_queue_0)
-    all_evts.start()
-    # Get all scenarios does not trigger any event
-    tp.get_scenarios()
-    snapshot = all_evts.capture()
+        register_id_0, register_queue_0 = Notifier.register()
+        all_evts = RecordingConsumer(register_id_0, register_queue_0)
+        all_evts.start()
+        # Get all scenarios does not trigger any event
+        tp.get_scenarios()
+        snapshot = all_evts.capture()
 
-    assert len(snapshot.collected_events) == 0
+        assert len(snapshot.collected_events) == 0
 
-    # Get one scenario does not trigger any event
-    tp.get(scenario.id)
-    snapshot = all_evts.capture()
-    assert len(snapshot.collected_events) == 0
+        # Get one scenario does not trigger any event
+        tp.get(scenario.id)
+        snapshot = all_evts.capture()
+        assert len(snapshot.collected_events) == 0
 
-    all_evts.stop()
+        all_evts.stop()
 
 
 def test_events_published_for_writing_dn():
-    input_config = Config.configure_data_node("the_input")
-    output_config = Config.configure_data_node("the_output")
-    task_config = Config.configure_task("the_task", identity, input=input_config, output=output_config)
-    sc_config = Config.configure_scenario(
-        "the_scenario", task_configs=[task_config], frequency=Frequency.DAILY, sequences={"the_seq": [task_config]}
-    )
-    scenario = tp.create_scenario(sc_config)
-    register_id_0, register_queue_0 = Notifier.register()
-    all_evts = RecordingConsumer(register_id_0, register_queue_0)
-    all_evts.start()
-
-    # Write input manually trigger 4 data node update events
-    # for last_edit_date, editor_id, editor_expiration_date and edit_in_progress
-    scenario.the_input.write("test")
-    snapshot = all_evts.capture()
-    assert len(snapshot.collected_events) == 4
-    assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 0
-    assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 4
-    assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 0
-    assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 0
-    assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 0
-    assert snapshot.operation_collected.get(EventOperation.CREATION, 0) == 0
-    assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 4
-    all_evts.stop()
+    with patch("sys.argv", ["prog"]):
+        input_config = Config.configure_data_node("the_input")
+        output_config = Config.configure_data_node("the_output")
+        task_config = Config.configure_task("the_task", identity, input=input_config, output=output_config)
+        sc_config = Config.configure_scenario(
+            "the_scenario", task_configs=[task_config], frequency=Frequency.DAILY, sequences={"the_seq": [task_config]}
+        )
+        scenario = tp.create_scenario(sc_config)
+        register_id_0, register_queue_0 = Notifier.register()
+        all_evts = RecordingConsumer(register_id_0, register_queue_0)
+        all_evts.start()
+
+        # Write input manually trigger 4 data node update events
+        # for last_edit_date, editor_id, editor_expiration_date and edit_in_progress
+        scenario.the_input.write("test")
+        snapshot = all_evts.capture()
+        assert len(snapshot.collected_events) == 4
+        assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 0
+        assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 4
+        assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 0
+        assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 0
+        assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 0
+        assert snapshot.operation_collected.get(EventOperation.CREATION, 0) == 0
+        assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 4
+        all_evts.stop()
 
 
 def test_events_published_for_scenario_submission():
-    input_config = Config.configure_data_node("the_input")
-    output_config = Config.configure_data_node("the_output")
-    task_config = Config.configure_task("the_task", identity, input=input_config, output=output_config)
-    sc_config = Config.configure_scenario(
-        "the_scenario", task_configs=[task_config], frequency=Frequency.DAILY, sequences={"the_seq": [task_config]}
-    )
-    scenario = tp.create_scenario(sc_config)
-    scenario.the_input.write("test")
-    register_id_0, register_queue_0 = Notifier.register()
-    all_evts = RecordingConsumer(register_id_0, register_queue_0)
-    all_evts.start()
-    # Submit a scenario triggers:
-    # 1 scenario submission event
-    # 7 dn update events (for last_edit_date, editor_id(x2), editor_expiration_date(x2) and edit_in_progress(x2))
-    # 1 job creation event
-    # 3 job update events (for status: PENDING, RUNNING and COMPLETED)
-    # 1 submission creation event
-    # 1 submission update event for jobs
-    # 3 submission update events (for status: PENDING, RUNNING and COMPLETED)
-    # 1 submission update event for is_completed
-    scenario.submit()
-    snapshot = all_evts.capture()
-    assert len(snapshot.collected_events) == 17
-    assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 0
-    assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 7
-    assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 0
-    assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 0
-    assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 1
-    assert snapshot.entity_type_collected.get(EventEntityType.JOB, 0) == 4
-    assert snapshot.entity_type_collected.get(EventEntityType.SUBMISSION, 0) == 5
-    assert snapshot.operation_collected.get(EventOperation.CREATION, 0) == 2
-    assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 14
-    assert snapshot.operation_collected.get(EventOperation.SUBMISSION, 0) == 1
-
-    assert snapshot.attr_name_collected["last_edit_date"] == 1
-    assert snapshot.attr_name_collected["editor_id"] == 2
-    assert snapshot.attr_name_collected["editor_expiration_date"] == 2
-    assert snapshot.attr_name_collected["edit_in_progress"] == 2
-    assert snapshot.attr_name_collected["status"] == 3
-    assert snapshot.attr_name_collected["jobs"] == 1
-    assert snapshot.attr_name_collected["submission_status"] == 3
-
-    all_evts.stop()
+    with patch("sys.argv", ["prog"]):
+        input_config = Config.configure_data_node("the_input")
+        output_config = Config.configure_data_node("the_output")
+        task_config = Config.configure_task("the_task", identity, input=input_config, output=output_config)
+        sc_config = Config.configure_scenario(
+            "the_scenario", task_configs=[task_config], frequency=Frequency.DAILY, sequences={"the_seq": [task_config]}
+        )
+        scenario = tp.create_scenario(sc_config)
+        scenario.the_input.write("test")
+        register_id_0, register_queue_0 = Notifier.register()
+        all_evts = RecordingConsumer(register_id_0, register_queue_0)
+        all_evts.start()
+        # Submit a scenario triggers:
+        # 1 scenario submission event
+        # 7 dn update events (for last_edit_date, editor_id(x2), editor_expiration_date(x2) and edit_in_progress(x2))
+        # 1 job creation event
+        # 3 job update events (for status: PENDING, RUNNING and COMPLETED)
+        # 1 submission creation event
+        # 1 submission update event for jobs
+        # 3 submission update events (for status: PENDING, RUNNING and COMPLETED)
+        # 1 submission update event for is_completed
+        scenario.submit()
+        snapshot = all_evts.capture()
+        assert len(snapshot.collected_events) == 17
+        assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 0
+        assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 7
+        assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 0
+        assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 0
+        assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 1
+        assert snapshot.entity_type_collected.get(EventEntityType.JOB, 0) == 4
+        assert snapshot.entity_type_collected.get(EventEntityType.SUBMISSION, 0) == 5
+        assert snapshot.operation_collected.get(EventOperation.CREATION, 0) == 2
+        assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 14
+        assert snapshot.operation_collected.get(EventOperation.SUBMISSION, 0) == 1
+
+        assert snapshot.attr_name_collected["last_edit_date"] == 1
+        assert snapshot.attr_name_collected["editor_id"] == 2
+        assert snapshot.attr_name_collected["editor_expiration_date"] == 2
+        assert snapshot.attr_name_collected["edit_in_progress"] == 2
+        assert snapshot.attr_name_collected["status"] == 3
+        assert snapshot.attr_name_collected["jobs"] == 1
+        assert snapshot.attr_name_collected["submission_status"] == 3
+
+        all_evts.stop()
 
 
 def test_events_published_for_scenario_deletion():
-    input_config = Config.configure_data_node("the_input")
-    output_config = Config.configure_data_node("the_output")
-    task_config = Config.configure_task("the_task", identity, input=input_config, output=output_config)
-    sc_config = Config.configure_scenario(
-        "the_scenario", task_configs=[task_config], frequency=Frequency.DAILY, sequences={"the_seq": [task_config]}
-    )
-    scenario = tp.create_scenario(sc_config)
-    scenario.the_input.write("test")
-    scenario.submit()
-    register_id_0, register_queue_0 = Notifier.register()
-    all_evts = RecordingConsumer(register_id_0, register_queue_0)
-    all_evts.start()
-    # Delete a scenario trigger 8 deletion events
-    # 1 scenario deletion event
-    # 1 cycle deletion event
-    # 2 dn deletion events (for input and output)
-    # 1 task deletion event
-    # 1 sequence deletion event
-    # 1 job deletion event
-    # 1 submission deletion event
-    tp.delete(scenario.id)
-    snapshot = all_evts.capture()
-
-    assert len(snapshot.collected_events) == 8
-    assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 1
-    assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 2
-    assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 1
-    assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 1
-    assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 1
-    assert snapshot.entity_type_collected.get(EventEntityType.SUBMISSION, 0) == 1
-    assert snapshot.entity_type_collected.get(EventEntityType.JOB, 0) == 1
-    assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 0
-    assert snapshot.operation_collected.get(EventOperation.SUBMISSION, 0) == 0
-    assert snapshot.operation_collected.get(EventOperation.DELETION, 0) == 8
-
-    all_evts.stop()
+    with patch("sys.argv", ["prog"]):
+        input_config = Config.configure_data_node("the_input")
+        output_config = Config.configure_data_node("the_output")
+        task_config = Config.configure_task("the_task", identity, input=input_config, output=output_config)
+        sc_config = Config.configure_scenario(
+            "the_scenario", task_configs=[task_config], frequency=Frequency.DAILY, sequences={"the_seq": [task_config]}
+        )
+        scenario = tp.create_scenario(sc_config)
+        scenario.the_input.write("test")
+        scenario.submit()
+        register_id_0, register_queue_0 = Notifier.register()
+        all_evts = RecordingConsumer(register_id_0, register_queue_0)
+        all_evts.start()
+        # Delete a scenario trigger 8 deletion events
+        # 1 scenario deletion event
+        # 1 cycle deletion event
+        # 2 dn deletion events (for input and output)
+        # 1 task deletion event
+        # 1 sequence deletion event
+        # 1 job deletion event
+        # 1 submission deletion event
+        tp.delete(scenario.id)
+        snapshot = all_evts.capture()
+
+        assert len(snapshot.collected_events) == 8
+        assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 1
+        assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 2
+        assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 1
+        assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 1
+        assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 1
+        assert snapshot.entity_type_collected.get(EventEntityType.SUBMISSION, 0) == 1
+        assert snapshot.entity_type_collected.get(EventEntityType.JOB, 0) == 1
+        assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 0
+        assert snapshot.operation_collected.get(EventOperation.SUBMISSION, 0) == 0
+        assert snapshot.operation_collected.get(EventOperation.DELETION, 0) == 8
+
+        all_evts.stop()
 
 
 def test_job_events():
@@ -285,39 +290,40 @@ def test_job_events():
 
 
 def test_scenario_events():
-    input_config = Config.configure_data_node("the_input")
-    output_config = Config.configure_data_node("the_output")
-    task_config = Config.configure_task("the_task", identity, input=input_config, output=output_config)
-    sc_config = Config.configure_scenario(
-        "the_scenario", task_configs=[task_config], frequency=Frequency.DAILY, sequences={"the_seq": [task_config]}
-    )
-    register_id, register_queue = Notifier.register(entity_type=EventEntityType.SCENARIO)
-    consumer = RecordingConsumer(register_id, register_queue)
-    consumer.start()
-    scenario = tp.create_scenario(sc_config)
-
-    snapshot = consumer.capture()
-    assert len(snapshot.collected_events) == 1
-    assert snapshot.collected_events[0].operation == EventOperation.CREATION
-    assert snapshot.collected_events[0].entity_type == EventEntityType.SCENARIO
-    assert snapshot.collected_events[0].metadata.get("config_id") == scenario.config_id
-
-    scenario.submit()
-    snapshot = consumer.capture()
-    assert len(snapshot.collected_events) == 1
-    assert snapshot.collected_events[0].operation == EventOperation.SUBMISSION
-    assert snapshot.collected_events[0].entity_type == EventEntityType.SCENARIO
-    assert snapshot.collected_events[0].metadata.get("config_id") == scenario.config_id
-
-    # Delete scenario
-    tp.delete(scenario.id)
-    snapshot = consumer.capture()
-    assert len(snapshot.collected_events) == 1
-
-    assert snapshot.collected_events[0].operation == EventOperation.DELETION
-    assert snapshot.collected_events[0].entity_type == EventEntityType.SCENARIO
-
-    consumer.stop()
+    with patch("sys.argv", ["prog"]):
+        input_config = Config.configure_data_node("the_input")
+        output_config = Config.configure_data_node("the_output")
+        task_config = Config.configure_task("the_task", identity, input=input_config, output=output_config)
+        sc_config = Config.configure_scenario(
+            "the_scenario", task_configs=[task_config], frequency=Frequency.DAILY, sequences={"the_seq": [task_config]}
+        )
+        register_id, register_queue = Notifier.register(entity_type=EventEntityType.SCENARIO)
+        consumer = RecordingConsumer(register_id, register_queue)
+        consumer.start()
+        scenario = tp.create_scenario(sc_config)
+
+        snapshot = consumer.capture()
+        assert len(snapshot.collected_events) == 1
+        assert snapshot.collected_events[0].operation == EventOperation.CREATION
+        assert snapshot.collected_events[0].entity_type == EventEntityType.SCENARIO
+        assert snapshot.collected_events[0].metadata.get("config_id") == scenario.config_id
+
+        scenario.submit()
+        snapshot = consumer.capture()
+        assert len(snapshot.collected_events) == 1
+        assert snapshot.collected_events[0].operation == EventOperation.SUBMISSION
+        assert snapshot.collected_events[0].entity_type == EventEntityType.SCENARIO
+        assert snapshot.collected_events[0].metadata.get("config_id") == scenario.config_id
+
+        # Delete scenario
+        tp.delete(scenario.id)
+        snapshot = consumer.capture()
+        assert len(snapshot.collected_events) == 1
+
+        assert snapshot.collected_events[0].operation == EventOperation.DELETION
+        assert snapshot.collected_events[0].entity_type == EventEntityType.SCENARIO
+
+        consumer.stop()
 
 
 def test_data_node_events():

tests/core/repository/test_encoding.py

@@ -8,38 +8,41 @@
 # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 # an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
+from unittest.mock import patch
 
 import taipy.core.taipy as tp
 from taipy.core.config import Config
 
 
 def test_no_special_characters():
-    scenario_config = Config.configure_scenario("scenario_1")
+    with patch("sys.argv", ["prog"]):
+        scenario_config = Config.configure_scenario("scenario_1")
 
-    scenario = tp.create_scenario(scenario_config, name="martin")
-    assert scenario.name == "martin"
-    scenarios = tp.get_scenarios()
-    assert len(scenarios) == 1
-    assert scenarios[0].name == "martin"
+        scenario = tp.create_scenario(scenario_config, name="martin")
+        assert scenario.name == "martin"
+        scenarios = tp.get_scenarios()
+        assert len(scenarios) == 1
+        assert scenarios[0].name == "martin"
 
 
 def test_many_special_characters():
-    scenario_config = Config.configure_scenario("scenario_1")
-
-    special_characters = (
-        "!#$%&'()*+,-./:;<=>?@[]^_`\\{"
-        "|}~¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º"
-        "»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ"
-        "×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñò"
-        "óôõö÷øùúûüýþÿĀāĂ㥹ĆćĈĉĊċČčĎ"
-        "ďĐđĒēĔĕĖėĘęĚěĜĝĞğĠġĢģĤĥĦħĨĩĪ"
-        "īĬĭĮįİIJijĴĵĶķĸĹĺĻļĽľĿŀŁłŃńŅņŇ"
-        "ňʼnŊŋŌōŎŏŐőŒœŔŕŖŗŘřŚśŜŝŞşŠšŢţ"
-        "ŤťŦŧŨũŪūŬŭŮůŰűŲųŴŵŶŷŸŹźŻżŽžſ"
-    )
-
-    scenario = tp.create_scenario(scenario_config, name=special_characters)
-    assert scenario.name == special_characters
-    scenarios = tp.get_scenarios()
-    assert len(scenarios) == 1
-    assert scenarios[0].name == special_characters
+    with patch("sys.argv", ["prog"]):
+        scenario_config = Config.configure_scenario("scenario_1")
+
+        special_characters = (
+            "!#$%&'()*+,-./:;<=>?@[]^_`\\{"
+            "|}~¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º"
+            "»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ"
+            "×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñò"
+            "óôõö÷øùúûüýþÿĀāĂ㥹ĆćĈĉĊċČčĎ"
+            "ďĐđĒēĔĕĖėĘęĚěĜĝĞğĠġĢģĤĥĦħĨĩĪ"
+            "īĬĭĮįİIJijĴĵĶķĸĹĺĻļĽľĿŀŁłŃńŅņŇ"
+            "ňʼnŊŋŌōŎŏŐőŒœŔŕŖŗŘřŚśŜŝŞşŠšŢţ"
+            "ŤťŦŧŨũŪūŬŭŮůŰűŲųŴŵŶŷŸŹźŻżŽžſ"
+        )
+
+        scenario = tp.create_scenario(scenario_config, name=special_characters)
+        assert scenario.name == special_characters
+        scenarios = tp.get_scenarios()
+        assert len(scenarios) == 1
+        assert scenarios[0].name == special_characters