Align the yes/no prompt in verdi computer delete with other prompts

The yes/no prompt of `verdi computer delete` is the only prompt in the CLI that
does not accept 'y' as valid answer but only 'yes'. This has been aligned with
the other prompts to also support 'y'.

Furthermore, no prompt is invoked when no nodes are associated with the
computer.

The tests have been restructured to more granular test cases and the names have
been cleaned up

We had to increase check count in `MockProcess` to avoid the timeout.

Author: Krishnabhujade

src/aiida/cmdline/commands/cmd_computer.py

@@ -628,30 +628,35 @@ def computer_delete(computer, dry_run):
     builder = QueryBuilder()
     builder.append(Computer, filters={'label': label}, tag='computer')
     builder.append(Node, with_computer='computer', project=Node.fields.pk)
-    node_pks = builder.all(flat=True)
+    associated_nodes_pk = builder.all(flat=True)
 
-    echo.echo_report(f'This computer has {len(node_pks)} associated nodes')
+    echo.echo_report(f'This computer has {len(associated_nodes_pk)} associated nodes')
 
     def _dry_run_callback(pks):
         if pks:
             echo.echo_report('The nodes with the following pks would be deleted: ' + ' '.join(map(str, pks)))
-            echo.echo_warning(f'YOU ARE ABOUT TO DELETE {len(pks)} NODES! THIS CANNOT BE UNDONE!')
-        confirm = click.prompt('Shall I continue? [yes/N]', type=str) == 'yes'
+            echo.echo_warning(
+                f'YOU ARE ABOUT TO DELETE {len(pks)} NODES AND COMPUTER {label!r}! THIS CANNOT BE UNDONE!'
+            )
+
+        confirm = click.confirm('Shall I continue?', default=False)
         if not confirm:
             raise click.Abort
         return not confirm
 
-    delete_nodes(node_pks, dry_run=dry_run or _dry_run_callback)
+    if associated_nodes_pk:
+        delete_nodes(associated_nodes_pk, dry_run=dry_run or _dry_run_callback)
 
     if dry_run:
         return
 
+    # We delete the computer separately from the associated nodes, since the computer pk is in a different table
     try:
         orm.Computer.collection.delete(computer.pk)
     except InvalidOperation as error:
         echo.echo_critical(str(error))
 
-    echo.echo_success(f'Computer `{label}` {"and all its associated nodes" if node_pks else ""} deleted.')
+    echo.echo_success(f'Computer `{label}` {"and all its associated nodes " if associated_nodes_pk else ""}deleted.')
 
 
 class LazyConfigureGroup(VerdiCommandGroup):

tests/cmdline/commands/test_computer.py

@@ -773,77 +773,113 @@ def test_computer_relabel(self):
         # The new label should be available
         orm.Computer.collection.get(label='comp_cli_test_computer')
 
-    def test_computer_delete_with_nodes(self):
-        """check if 'verdi computer delete' works when there are associated nodes"""
+    # Ensures that 'yes' works for backwards compatibility, see issue #6422
+    @pytest.mark.parametrize('user_input', ['y', 'yes'])
+    def test_computer_delete_existing_computer_successful(self, user_input):
+        """Test if `verdi computer delete` successfully deletes when applied on an existing computer."""
         from aiida.common.exceptions import NotExistent
 
-        label = 'computer_69'
-        compute_temp = orm.Computer(
+        label = 'computer_temp'
+        computer_temp = orm.Computer(
             label=label,
             hostname='localhost',
             transport_type='core.local',
             scheduler_type='core.direct',
             workdir='/tmp/aiida',
         )
-        compute_temp.store()
-        compute_temp.configure(safe_interval=0)
+        computer_temp.store()
+        computer_temp.configure(safe_interval=0)
 
-        c_label = 'code_69'
+        code_label = 'code_temp'
         orm.InstalledCode(
-            label=c_label,
+            label=code_label,
             default_calc_job_plugin='core.arithmetic.add',
-            computer=compute_temp,
+            computer=computer_temp,
             filepath_executable='/remote/abs/path',
         ).store()
 
-        false_user_input = 'y'  # most common mistake
-        user_input = 'yes'
-
-        # Abort in case of wrong input
-        self.cli_runner(computer_delete, [label], user_input=false_user_input, raises=True)
-        orm.load_code(c_label)
-
-        # Safety check in case of --dry-run
-        options = [label, '--dry-run']
-        self.cli_runner(computer_delete, options)
-        orm.load_code(c_label)
-
         # A successul delete, including all associated nodes
         self.cli_runner(computer_delete, [label], user_input=user_input)
 
         with pytest.raises(NotExistent):
             orm.Computer.collection.get(label=label)
 
         with pytest.raises(NotExistent):
-            orm.load_code(c_label)
+            orm.load_computer(label)
+
+        with pytest.raises(NotExistent):
+            orm.load_code(code_label)
+
+    # Ensures that 'yes' works for backwards compatibility, see issue #6422
+    @pytest.mark.parametrize('user_input', ['y', 'yes'])
+    def test_computer_delete_existing_computer_successful_no_assciated_nodes(self, user_input):
+        """Test if `verdi computer delete` successfully deletes when applied on a computer without associated nodes.
 
-    def test_computer_delete(self):
-        """Test if 'verdi computer delete' command works"""
+        In this case no prompt should appear."""
         from aiida.common.exceptions import NotExistent
 
-        # Setup a computer to delete during the test
-        label = 'computer_for_test_label'
-        orm.Computer(
+        label = 'computer_temp'
+        computer_temp = orm.Computer(
             label=label,
             hostname='localhost',
             transport_type='core.local',
             scheduler_type='core.direct',
             workdir='/tmp/aiida',
-        ).store()
-        # and configure it
-        options = ['core.local', label, '--non-interactive', '--safe-interval', '0']
-        self.cli_runner(computer_configure, options)
+        )
+        computer_temp.store()
 
-        # See if the command complains about not getting an invalid computer
-        user_input = 'yes'
-        self.cli_runner(computer_delete, ['computer_that_does_not_exist'], raises=True, user_input=user_input)
+        # A successul delete, including all associated nodes
+        self.cli_runner(computer_delete, [label])
 
-        # Delete a computer name successully.
-        self.cli_runner(computer_delete, [label], user_input=user_input)
-        # Check that the computer really was deleted
         with pytest.raises(NotExistent):
             orm.Computer.collection.get(label=label)
 
+        with pytest.raises(NotExistent):
+            orm.load_computer(label)
+
+    def test_computer_delete_existing_computer_not_deleted(self):
+        """Test if `verdi computer delete` behaves correctly when applied on an existing computer without deletion.
+
+        This case includes when the user enters a wrong input on the prompt and the usage of the dry-run option."""
+        label = 'computer_temp'
+        computer_temp = orm.Computer(
+            label=label,
+            hostname='localhost',
+            transport_type='core.local',
+            scheduler_type='core.direct',
+            workdir='/tmp/aiida',
+        )
+        computer_temp.store()
+        computer_temp.configure(safe_interval=0)
+
+        code_label = 'code_temp'
+        orm.InstalledCode(
+            label=code_label,
+            default_calc_job_plugin='core.arithmetic.add',
+            computer=computer_temp,
+            filepath_executable='/remote/abs/path',
+        ).store()
+
+        # Tests that Abort in case of wrong input
+        false_user_input = ''  # most common input that could happen by accident
+        self.cli_runner(computer_delete, [label], user_input=false_user_input, raises=True)
+        # raises an error if not existing
+        assert orm.load_code(code_label).label == code_label
+        assert orm.Computer.collection.get(label=label).label == label
+
+        # Safety check in case of --dry-run
+        options = [label, '--dry-run']
+        self.cli_runner(computer_delete, options, user_input='y')
+        # raises an error if not existing
+        assert orm.load_code(code_label).label == code_label
+        assert orm.Computer.collection.get(label=label).label == label
+
+    def test_computer_delete_nonexisting_computer(self):
+        """Test if `verdi computer delete` command behaves correctly when deleting a nonexisting computer"""
+        # See if the command complains about not getting an existing computer
+        result = self.cli_runner(computer_delete, ['computer_that_does_not_exist'], user_input='y', raises=True)
+        assert 'no Computer found with LABEL<computer_that_does_not_exist>' in result.stderr
+
 
 @pytest.mark.parametrize('non_interactive_editor', ('vim -cwq',), indirect=True)
 def test_computer_duplicate_interactive(run_cli_command, aiida_localhost, non_interactive_editor):

tests/manage/test_profile_access.py

@@ -201,12 +201,13 @@ def _wait_for_checkfile(self, temppath_checkfile):
         import time
 
         check_count = 0
+        max_check_count = 400
 
-        while check_count < 100 and not temppath_checkfile.exists():
+        while check_count < max_check_count and not temppath_checkfile.exists():
             time.sleep(0.1)
             check_count += 1
 
-        if check_count == 100:
+        if check_count == max_check_count:
             raise RuntimeError('Process loading was too slow!')
 
     def start(self, should_raise=False, runtime_secs=60):