fix: Handle input parameters classified as multiple value click options

samcli/cli/cli_config_file.py

@@ -102,6 +102,7 @@ def __call__(self, config_path: Path, config_env: str, cmd_names: List[str]) ->
             # NOTE(TheSriram): change from tomlkit table type to normal dictionary,
             # so that click defaults work out of the box.
             resolved_config = dict(samconfig.get_all(self.cmd_names, self.section, env=config_env).items())
+            handle_parse_options(resolved_config)
             LOG.debug("Configuration values successfully loaded.")
             LOG.debug("Configuration values are: %s", resolved_config)
 
@@ -123,6 +124,55 @@ def __call__(self, config_path: Path, config_env: str, cmd_names: List[str]) ->
         return resolved_config
 
 
+def handle_parse_options(resolved_config: dict) -> None:
+    """
+    Click does some handling of options to convert them to the intended types.
+    When injecting the options to click through a samconfig, we should do a similar
+    parsing of the options to ensure we pass the intended type.
+
+    E.g. if multiple is defined in the click option but only a single value is passed,
+    handle it the same way click does by converting it to a list first.
+
+    Mutates the resolved_config object
+
+    Parameters
+    ----------
+    resolved_config: dict
+        Configuration options extracted from the configuration file
+    """
+    options_map = get_options_map()
+    for config_name, config_value in resolved_config.items():
+        if config_name in options_map:
+            try:
+                allow_multiple = options_map[config_name].multiple
+                if allow_multiple and not isinstance(config_value, list):
+                    resolved_config[config_name] = [config_value]
+                    LOG.debug(
+                        f"Adjusting value of {config_name} to be a list "
+                        f"since this option is defined with 'multiple=True'"
+                    )
+            except (AttributeError, KeyError):
+                LOG.debug(f"Unable to parse option: {config_name}. Leaving option as inputted")
+
+
+def get_options_map() -> dict:
+    """
+    Attempt to get all of the options that exist for a command.
+    Return a mapping from each option name to that options' properties.
+
+    Returns
+    -------
+    dict
+        Dict of command options if successful, None otherwise
+    """
+    try:
+        command_options = click.get_current_context().command.params
+        return {command_option.name: command_option for command_option in command_options}
+    except AttributeError:
+        LOG.debug("Unable to get parameters from click context.")
+        return {}
+
+
 def configuration_callback(
     cmd_name: str,
     option_name: str,

tests/integration/local/start_api/start_api_integ_base.py

@@ -27,6 +27,7 @@ class StartApiIntegBaseClass(TestCase):
     integration_dir = str(Path(__file__).resolve().parents[2])
     invoke_image: Optional[List] = None
     layer_cache_base_dir: Optional[str] = None
+    config_file: Optional[str] = None
 
     build_before_invoke = False
     build_overrides: Optional[Dict[str, str]] = None
@@ -103,6 +104,9 @@ def start_api(cls):
             for image in cls.invoke_image:
                 command_list += ["--invoke-image", image]
 
+        if cls.config_file:
+            command_list += ["--config-file", cls.config_file]
+
         cls.start_api_process = (
             Popen(command_list, stderr=PIPE, stdout=PIPE)
             if not cls.project_directory

tests/integration/local/start_api/test_start_api.py

@@ -3179,3 +3179,19 @@ def test_can_invoke_lambda_layer_successfully(self):
         response = requests.get(self.url + "/", timeout=300)
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.content.decode("utf-8"), '"Layer1"')
+
+
+class TestStartApiDebugPortsConfigFile(StartApiIntegBaseClass):
+    template_path = "/testdata/start_api/serverless-sample-output.yaml"
+    config_file = "debug-config.toml"
+
+    def setUp(self):
+        self.url = "http://127.0.0.1:{}".format(self.port)
+
+    @pytest.mark.flaky(reruns=3)
+    @pytest.mark.timeout(timeout=600, method="thread")
+    def test_starts_process_successfully(self):
+        response = requests.get(self.url + "/hello-world", timeout=300)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"hello": "world"})

tests/integration/testdata/start_api/debug-config.toml

@@ -0,0 +1,4 @@
+version = 0.1
+
+[default.local_start_api.parameters]
+debug_port = 5858

tests/unit/cli/test_cli_config_file.py

@@ -1,7 +1,9 @@
 import os
 import tempfile
+from dataclasses import dataclass
 
 from pathlib import Path
+from typing import List, Optional
 from unittest import TestCase, skipIf
 from unittest.mock import MagicMock, patch
 
@@ -15,6 +17,7 @@
     configuration_callback,
     get_ctx_defaults,
     save_command_line_args_to_config,
+    handle_parse_options,
 )
 from samcli.lib.config.exceptions import SamConfigFileReadException, SamConfigVersionException
 from samcli.lib.config.samconfig import DEFAULT_ENV
@@ -38,7 +41,8 @@ def setUp(self):
         self.parameters = "parameters"
         self.cmd_name = "topic"
 
-    def test_toml_valid_with_section(self):
+    @patch("samcli.cli.cli_config_file.handle_parse_options")
+    def test_toml_valid_with_section(self, mock_handle_parse_options):
         config_dir = tempfile.gettempdir()
         config_path = Path(config_dir, "samconfig.toml")
         config_path.write_text("version=0.1\n[config_env.topic.parameters]\nword='clarity'\n")
@@ -363,3 +367,87 @@ def test_dont_save_command_line_args_if_value_is_none(self):
         self.assertNotIn("save_params", params.keys(), "--save-params should not be saved to config")
         self.assertNotIn("none_param", params.keys(), "Param with None value should not be saved to config")
         self.assertNotIn(None, params.values(), "None value should not be saved to config")
+
+
+@dataclass
+class MockParam:
+    multiple: Optional[bool]
+    name: Optional[str]
+
+
+@dataclass
+class MockCommand:
+    params: List[MockParam]
+
+
+@dataclass
+class MockCommandContext:
+    command: MockCommand
+
+
+class TestHandleParseOptions(TestCase):
+    @patch("samcli.cli.cli_config_file.click")
+    def test_succeeds_updating_option(self, mock_click):
+        mock_param = MockParam(multiple=True, name="debug_port")
+        mock_command = MockCommand(params=[mock_param])
+        mock_context = MockCommandContext(command=mock_command)
+        mock_click.get_current_context.return_value = mock_context
+        resolved_config = {"debug_port": 5858}
+        handle_parse_options(resolved_config)
+        self.assertEqual(resolved_config, {"debug_port": [5858]})
+
+    @patch("samcli.cli.cli_config_file.click")
+    def test_doesnt_update_not_needed_options(self, mock_click):
+        mock_param = MockParam(multiple=True, name="debug_port")
+        mock_command = MockCommand(params=[mock_param])
+        mock_context = MockCommandContext(command=mock_command)
+        mock_click.get_current_context.return_value = mock_context
+        resolved_config = {"debug_port": [5858]}
+        handle_parse_options(resolved_config)
+        self.assertEqual(resolved_config, {"debug_port": [5858]})
+
+    @patch("samcli.cli.cli_config_file.click")
+    def test_doesnt_update_multiple_false(self, mock_click):
+        mock_param = MockParam(multiple=False, name="debug_port")
+        mock_command = MockCommand(params=[mock_param])
+        mock_context = MockCommandContext(command=mock_command)
+        mock_click.get_current_context.return_value = mock_context
+        resolved_config = {"debug_port": 5858}
+        handle_parse_options(resolved_config)
+        self.assertEqual(resolved_config, {"debug_port": 5858})
+
+    @patch("samcli.cli.cli_config_file.click")
+    def test_doesnt_update_not_found(self, mock_click):
+        mock_param = MockParam(multiple=False, name="debug_port")
+        mock_command = MockCommand(params=[mock_param])
+        mock_context = MockCommandContext(command=mock_command)
+        mock_click.get_current_context.return_value = mock_context
+        resolved_config = {"other_option": "hello"}
+        handle_parse_options(resolved_config)
+        self.assertEqual(resolved_config, {"other_option": "hello"})
+
+    @patch("samcli.cli.cli_config_file.LOG")
+    @patch("samcli.cli.cli_config_file.click")
+    def test_handles_invalid_param_name(self, mock_click, mock_log):
+        mock_param = None
+        mock_command = MockCommand(params=[mock_param])
+        mock_context = MockCommandContext(command=mock_command)
+        mock_click.get_current_context.return_value = mock_context
+        resolved_config = {"other_option": "hello"}
+        handle_parse_options(resolved_config)
+        self.assertEqual(resolved_config, {"other_option": "hello"})
+        mock_log.debug.assert_called_once_with("Unable to get parameters from click context.")
+
+    @patch("samcli.cli.cli_config_file.get_options_map")
+    @patch("samcli.cli.cli_config_file.LOG")
+    @patch("samcli.cli.cli_config_file.click")
+    def test_handles_invalid_param_multiple(self, mock_click, mock_log, mock_get_options_map):
+        mock_param = None
+        mock_command = MockCommand(params=[mock_param])
+        mock_context = MockCommandContext(command=mock_command)
+        mock_click.get_current_context.return_value = mock_context
+        resolved_config = {"other_option": "hello"}
+        mock_get_options_map.return_value = {"other_option": "option"}
+        handle_parse_options(resolved_config)
+        self.assertEqual(resolved_config, {"other_option": "hello"})
+        mock_log.debug.assert_called_once_with("Unable to parse option: other_option. Leaving option as inputted")