🧪 template_config: add test coverage

Add tests covering the template config processing pipeline,
parse_template_vars resolution chain (file/URL/JSON), interactive
prompting via CliRunner, and computer/code setup from template configs.

Author: GeigerJ2

tests/cmdline/params/options/test_config.py

@@ -119,3 +119,56 @@ def test_template_config_with_template_vars(run_cli_command, tmp_path, template_
         result = run_cli_command(cmd_with_template, args)
         assert 'Label: my-computer' in result.output
         assert 'Hostname: localhost' in result.output
+
+
+@pytest.mark.parametrize(
+    ('user_input', 'expected_label'),
+    [
+        pytest.param('my-prompted-label\n', 'my-prompted-label', id='typed_value'),
+        pytest.param('\n', 'default-label', id='accept_default'),
+    ],
+)
+def test_template_config_interactive_prompting(run_cli_command, tmp_path, user_input, expected_label):
+    """Interactive mode prompts for template variables; Enter accepts the default."""
+    filepath = tmp_path / 'config.yml'
+    filepath.write_text(
+        textwrap.dedent(
+            """\
+            label: '{{ label }}'
+            hostname: localhost
+            metadata:
+                template_variables:
+                    label:
+                        key_display: Computer Label
+                        description: A short name
+                        default: default-label
+            """
+        )
+    )
+
+    result = run_cli_command(cmd_with_template, ['--config', str(filepath)], user_input=user_input)
+    assert f'Label: {expected_label}' in result.output
+    assert 'Hostname: localhost' in result.output
+
+
+def test_template_config_interactive_choice(run_cli_command, tmp_path):
+    """Interactive mode with ``type: list`` constrains input to the given options."""
+    filepath = tmp_path / 'config.yml'
+    filepath.write_text(
+        textwrap.dedent(
+            """\
+            label: '{{ binary }}'
+            hostname: localhost
+            metadata:
+                template_variables:
+                    binary:
+                        type: list
+                        options:
+                            - pw
+                            - ph
+            """
+        )
+    )
+
+    result = run_cli_command(cmd_with_template, ['--config', str(filepath)], user_input='pw\n')
+    assert 'Label: pw' in result.output

tests/cmdline/utils/test_template_config.py

@@ -16,9 +16,25 @@
 from aiida.cmdline.utils.template_config import (
     _process_content,
     load_and_process_template,
+    parse_template_vars,
 )
 
 
+def _fake_response(text, *, ok=True):
+    """Build a fake ``requests.Response`` for monkeypatching ``requests.get``."""
+    import requests
+
+    class _Response:
+        status_code = 200 if ok else 500
+
+        def raise_for_status(self):
+            if not ok:
+                raise requests.ConnectionError(text)
+
+    _Response.text = text
+    return _Response()
+
+
 class TestProcessContent:
     """Tests for :func:`_process_content` — the core processing pipeline."""
 
@@ -58,17 +74,24 @@ def test_template_vars_without_metadata(self):
         result = _process_content(content, interactive=False, template_vars={'label': 'test'})
         assert result == {'label': 'test', 'hostname': 'localhost'}
 
+    def test_template_vars_without_metadata_warns_interactive(self, capsys):
+        """In interactive mode, template variables without metadata emit a warning but don't fail."""
+        content = "label: '{{ label }}'\nhostname: localhost\n"
+        result = _process_content(content, interactive=True)
+        assert result == {'label': '{{ label }}', 'hostname': 'localhost'}
+        assert 'no metadata found' in capsys.readouterr().out
+
     @pytest.mark.parametrize(
         ('content', 'match'),
         [
-            (':\ninvalid: [yaml', 'Invalid YAML'),
-            ('- item1\n- item2\n', 'Expected a YAML mapping'),
-            (
+            pytest.param(':\ninvalid: [yaml', 'Invalid YAML', id='invalid_yaml'),
+            pytest.param('- item1\n- item2\n', 'Expected a YAML mapping', id='non_dict_yaml'),
+            pytest.param(
                 "label: '{{ label }}'\nmetadata:\n  template_variables:\n    label:\n      description: x\n",
                 r'Template variables detected.*but no values provided',
+                id='missing_vars_non_interactive',
             ),
         ],
-        ids=['invalid_yaml', 'non_dict_yaml', 'missing_vars_non_interactive'],
     )
     def test_invalid_input_raises(self, content, match):
         with pytest.raises(click.BadParameter, match=match):
@@ -101,12 +124,15 @@ def test_registry_computer_format(self):
             interactive=False,
             template_vars={'label': 'eiger-mc', 'slurm_partition': 'normal', 'slurm_account': 'my_project'},
         )
-        assert result['label'] == 'eiger-mc'
-        assert '#SBATCH --partition=normal' in result['prepend_text']
-        assert '#SBATCH --account=my_project' in result['prepend_text']
-        assert '{username}' in result['work_dir']
-        assert '{tot_num_mpiprocs}' in result['mpirun_command']
-        assert 'metadata' not in result
+        assert result == {
+            'label': 'eiger-mc',
+            'hostname': 'eiger.cscs.ch',
+            'transport': 'core.ssh',
+            'scheduler': 'core.slurm',
+            'work_dir': '/scratch/{username}/aiida_run/',
+            'mpirun_command': 'srun -n {tot_num_mpiprocs}',
+            'prepend_text': '#SBATCH --partition=normal\n#SBATCH --account=my_project',
+        }
 
     def test_registry_code_format_with_multiline_expression(self):
         """Realistic code YAML with a multi-line Jinja2 expression (``{{ }}`` spanning two lines)."""
@@ -141,6 +167,70 @@ def test_from_file(self, tmp_path):
         result = load_and_process_template(str(filepath), interactive=False)
         assert result == {'label': 'my-computer', 'hostname': 'localhost'}
 
+    def test_from_url(self, monkeypatch):
+        """Loading a template from a URL fetches and processes the content."""
+        import requests
+
+        monkeypatch.setattr(
+            requests, 'get', lambda *a, **kw: _fake_response('label: url-computer\nhostname: remote-host\n')
+        )
+        result = load_and_process_template('https://example.com/config.yaml', interactive=False)
+        assert result == {'label': 'url-computer', 'hostname': 'remote-host'}
+
     def test_file_not_found(self):
         with pytest.raises(click.BadParameter, match='Failed to read file'):
             load_and_process_template('/nonexistent/path.yaml', interactive=False)
+
+    def test_url_failure(self, monkeypatch):
+        """A failing URL request raises ``click.BadParameter``."""
+        import requests
+
+        monkeypatch.setattr(requests, 'get', lambda *a, **kw: (_ for _ in ()).throw(requests.ConnectionError('fail')))
+        with pytest.raises(click.BadParameter, match='Failed to fetch URL'):
+            load_and_process_template('https://example.com/config.yaml', interactive=False)
+
+
+class TestParseTemplateVars:
+    """Tests for :func:`parse_template_vars` — file / URL / JSON resolution chain."""
+
+    def test_from_json_string(self):
+        result = parse_template_vars('{"key": "value", "num": "42"}')
+        assert result == {'key': 'value', 'num': '42'}
+
+    def test_from_yaml_file(self, tmp_path):
+        filepath = tmp_path / 'vars.yaml'
+        filepath.write_text('account: my_project\npartition: normal\n')
+        result = parse_template_vars(str(filepath))
+        assert result == {'account': 'my_project', 'partition': 'normal'}
+
+    def test_from_url(self, monkeypatch):
+        import requests
+
+        monkeypatch.setattr(requests, 'get', lambda *a, **kw: _fake_response('account: remote_project\n'))
+        result = parse_template_vars('https://example.com/vars.yaml')
+        assert result == {'account': 'remote_project'}
+
+    @pytest.mark.parametrize(
+        ('value', 'match'),
+        [
+            pytest.param('not valid json', 'Invalid JSON', id='invalid_json'),
+            pytest.param('["a", "b"]', 'must contain a YAML/JSON mapping', id='json_array'),
+            pytest.param('"just a string"', 'must contain a YAML/JSON mapping', id='json_string'),
+        ],
+    )
+    def test_invalid_input_raises(self, value, match):
+        with pytest.raises(click.BadParameter, match=match):
+            parse_template_vars(value)
+
+    @pytest.mark.parametrize(
+        ('file_content', 'match'),
+        [
+            pytest.param(':\n  [invalid yaml', 'Invalid YAML', id='invalid_yaml'),
+            pytest.param('- item1\n- item2\n', 'must contain a YAML/JSON mapping', id='non_dict_yaml'),
+        ],
+    )
+    def test_file_with_bad_content_raises(self, tmp_path, file_content, match):
+        filepath = tmp_path / 'bad.yaml'
+        filepath.write_text(file_content)
+        with pytest.raises(click.BadParameter, match=match):
+            parse_template_vars(str(filepath))