refactor: revert function filtering for sam local start-api

Remove function name filtering functionality from 'sam local start-api' command
while keeping it for 'sam local start-lambda'. This change:

- Removes function_logical_ids parameter from start-api CLI
- Removes function filtering logic from ApiProvider
- Removes function_logical_ids parameter from LocalApiService
- Removes all related integration and unit tests for start-api
- Updates samconfig tests to match new signature

The function filtering feature remains fully functional for
'sam local start-lambda' command.

Author: vicheey

samcli/commands/local/lib/local_api_service.py

@@ -40,10 +40,7 @@ def __init__(self, lambda_invoke_context, port, host, static_dir, disable_author
         self.cwd = lambda_invoke_context.get_cwd()
         self.disable_authorizer = disable_authorizer
         self.api_provider = ApiProvider(
-            lambda_invoke_context.stacks,
-            cwd=self.cwd,
-            disable_authorizer=disable_authorizer,
-            function_logical_ids=lambda_invoke_context.function_logical_ids,
+            lambda_invoke_context.stacks, cwd=self.cwd, disable_authorizer=disable_authorizer
         )
         self.lambda_runner = lambda_invoke_context.local_lambda_runner
         self.stderr_stream = lambda_invoke_context.stderr

samcli/commands/local/start_api/cli.py

@@ -60,7 +60,6 @@
     requires_credentials=False,
     context_settings={"max_content_width": 120},
 )
-@click.argument("function_logical_ids", nargs=-1, required=False)
 @configuration_option(provider=ConfigProvider(section="parameters"))
 @terraform_plan_file_option
 @hook_name_click_option(
@@ -108,7 +107,6 @@
 @print_cmdline_args
 def cli(
     ctx,
-    function_logical_ids,
     # start-api Specific Options
     host,
     port,
@@ -152,7 +150,6 @@ def cli(
 
     do_cli(
         ctx,
-        function_logical_ids,
         host,
         port,
         disable_authorizer,
@@ -186,7 +183,6 @@ def cli(
 
 def do_cli(  # pylint: disable=R0914
     ctx,
-    function_logical_ids,
     host,
     port,
     disable_authorizer,
@@ -260,7 +256,6 @@ def do_cli(  # pylint: disable=R0914
             container_host_interface=container_host_interface,
             invoke_images=processed_invoke_images,
             add_host=add_host,
-            function_logical_ids=function_logical_ids,
             no_mem_limit=no_mem_limit,
         ) as invoke_context:
             ssl_context = (ssl_cert_file, ssl_key_file) if ssl_cert_file else None

samcli/lib/providers/api_provider.py

@@ -1,26 +1,19 @@
 """Class that provides the Api with a list of routes from a Template"""
 
 import logging
-from typing import Iterator, List, Optional, Tuple
+from typing import Iterator, List, Optional
 
 from samcli.lib.providers.api_collector import ApiCollector
 from samcli.lib.providers.cfn_api_provider import CfnApiProvider
 from samcli.lib.providers.cfn_base_api_provider import CfnBaseApiProvider
 from samcli.lib.providers.provider import AbstractApiProvider, Api, Stack
 from samcli.lib.providers.sam_api_provider import SamApiProvider
-from samcli.local.apigw.route import Route
 
 LOG = logging.getLogger(__name__)
 
 
 class ApiProvider(AbstractApiProvider):
-    def __init__(
-        self,
-        stacks: List[Stack],
-        cwd: Optional[str] = None,
-        disable_authorizer: Optional[bool] = False,
-        function_logical_ids: Optional[Tuple[str, ...]] = None,
-    ):
+    def __init__(self, stacks: List[Stack], cwd: Optional[str] = None, disable_authorizer: Optional[bool] = False):
         """
         Initialize the class with template data. The template_dict is assumed
         to be valid, normalized and a dictionary. template_dict should be normalized by running any and all
@@ -38,21 +31,13 @@ def __init__(
             Optional working directory with respect to which we will resolve relative path to Swagger file
         disable_authorizer : Optional[bool]
             Optional flag to disable the collection of lambda authorizers
-        function_logical_ids : Optional[Tuple[str, ...]]
-            Optional tuple of function logical IDs to filter API routes by
         """
         self.stacks = stacks
 
         # Store a set of apis
         self.cwd = cwd
         self.disable_authorizer = disable_authorizer
-        self._function_logical_ids = function_logical_ids
         self.api = self._extract_api()
-
-        # Filter routes if function names provided
-        if function_logical_ids:
-            self.api = self._filter_api_routes(self.api, function_logical_ids)
-
         self.routes = self.api.routes
         LOG.debug("%d APIs found in the template", len(self.routes))
 
@@ -65,50 +50,6 @@ def get_all(self) -> Iterator[Api]:
 
         yield self.api
 
-    def _filter_api_routes(self, api: Api, function_logical_ids: Tuple[str, ...]) -> Api:
-        """
-        Filters API routes to only include those backed by specified functions.
-        Logs warnings for functions not referenced by any routes.
-
-        Parameters
-        ----------
-        api : Api
-            The Api object containing all routes
-        function_logical_ids : Tuple[str, ...]
-            Tuple of function logical IDs to filter by
-
-        Returns
-        -------
-        Api
-            The same Api object with filtered routes
-        """
-        function_logical_ids_set = set(function_logical_ids)
-
-        # Only filter if routes is a list (not a set of strings)
-        if not isinstance(api.routes, list):
-            return api
-
-        functions_with_routes = {
-            route.function_name
-            for route in api.routes
-            if isinstance(route, Route) and route.function_name in function_logical_ids_set
-        }
-        api.routes = [
-            route
-            for route in api.routes
-            if isinstance(route, Route) and route.function_name in function_logical_ids_set
-        ]
-
-        # Warn about functions without routes
-        functions_without_routes = function_logical_ids_set - functions_with_routes
-        if functions_without_routes:
-            LOG.warning(
-                "The following functions are not referenced by any API routes: %s",
-                ", ".join(sorted(functions_without_routes)),
-            )
-
-        return api
-
     def _extract_api(self) -> Api:
         """
         Extracts all the routes by running through the one providers. The provider that has the first type matched

tests/integration/local/start_api/test_start_api.py

@@ -5,7 +5,6 @@
 from unittest import skipIf
 import uuid
 import random
-import logging
 from pathlib import Path
 from typing import Dict
 
@@ -22,12 +21,10 @@
 from samcli.commands.local.cli_common.options import get_default_layer_cache_dir
 from samcli.local.apigw.route import Route
 from samcli.local.docker.utils import get_validated_container_client
-from tests.testing_utils import IS_WINDOWS, get_sam_command
+from tests.testing_utils import IS_WINDOWS
 from .start_api_integ_base import StartApiIntegBaseClass, WritableStartApiIntegBaseClass
 from ..invoke.layer_utils import LayerUtils
 
-LOG = logging.getLogger(__name__)
-
 
 @parameterized_class(
     ("template_path",),
@@ -3443,165 +3440,3 @@ def test_starts_process_successfully(self):
 
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.json(), {"hello": "world"})
-
-
-class TestFunctionNameFilteringWithFilter(StartApiIntegBaseClass):
-    """Test function name filtering with specific functions"""
-
-    template_path = "/testdata/start_api/template.yaml"
-
-    @classmethod
-    def setUpClass(cls):
-        cls.command_list = [
-            get_sam_command(),
-            "local",
-            "start-api",
-            "HelloWorldFunction",
-            "EchoEventFunction",
-            "-t",
-            cls.integration_dir + cls.template_path,
-        ]
-        super().setUpClass()
-
-    def setUp(self):
-        self.url = f"http://127.0.0.1:{self.port}"
-
-    @pytest.mark.flaky(reruns=3)
-    @pytest.mark.timeout(timeout=600, method="thread")
-    def test_accessing_filtered_route(self):
-        """Test accessing a route backed by a filtered function"""
-        response = requests.get(self.url + "/anyandall", timeout=300)
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.json(), {"hello": "world"})
-
-    @pytest.mark.flaky(reruns=3)
-    @pytest.mark.timeout(timeout=600, method="thread")
-    def test_accessing_filtered_route_post(self):
-        """Test accessing another filtered route"""
-        response = requests.post(self.url + "/echoeventbody", json={}, timeout=300)
-        self.assertEqual(response.status_code, 200)
-
-    @pytest.mark.flaky(reruns=3)
-    @pytest.mark.timeout(timeout=600, method="thread")
-    def test_accessing_non_filtered_route(self):
-        """Test accessing a route backed by non-filtered function returns 404"""
-        response = requests.get(self.url + "/onlysetbody", timeout=300)
-        self.assertIn(response.status_code, [403, 404])
-
-
-class TestFunctionNameFilteringMultipleRoutes(StartApiIntegBaseClass):
-    """Test that filtering works correctly when functions have multiple routes"""
-
-    template_path = "/testdata/start_api/template.yaml"
-
-    @classmethod
-    def setUpClass(cls):
-        cls.command_list = [
-            get_sam_command(),
-            "local",
-            "start-api",
-            "HelloWorldFunction",
-            "-t",
-            cls.integration_dir + cls.template_path,
-        ]
-        super().setUpClass()
-
-    def setUp(self):
-        self.url = f"http://127.0.0.1:{self.port}"
-
-    @pytest.mark.flaky(reruns=3)
-    @pytest.mark.timeout(timeout=600, method="thread")
-    def test_all_routes_for_filtered_function_available(self):
-        """Test that all routes for a filtered function are available"""
-        self.assertEqual(requests.get(self.url + "/anyandall", timeout=300).status_code, 200)
-        self.assertEqual(requests.post(self.url + "/id", json={}, timeout=300).status_code, 200)
-        self.assertEqual(requests.get(self.url + "/proxypath/some/path", timeout=300).status_code, 200)
-
-
-class TestFunctionNameFilteringWarmContainersEager(StartApiIntegBaseClass):
-    """Test function filtering with EAGER warm containers"""
-
-    template_path = "/testdata/start_api/template-warm-containers.yaml"
-    container_mode = ContainersInitializationMode.EAGER.value
-    mode_env_variable = str(uuid.uuid4())
-    parameter_overrides = {"ModeEnvVariable": mode_env_variable}
-
-    @classmethod
-    def setUpClass(cls):
-        cls.command_list = [
-            get_sam_command(),
-            "local",
-            "start-api",
-            "HelloWorldFunction",
-            "-t",
-            cls.integration_dir + cls.template_path,
-            "--warm-containers",
-            cls.container_mode,
-            "--parameter-overrides",
-            cls._make_parameter_override_arg(cls.parameter_overrides),
-        ]
-        super().setUpClass()
-
-    def setUp(self):
-        self.url = f"http://127.0.0.1:{self.port}"
-
-    @pytest.mark.flaky(reruns=3)
-    @pytest.mark.timeout(timeout=600, method="thread")
-    def test_only_filtered_function_has_container(self):
-        """Test that only the filtered function has a pre-warmed container in EAGER mode"""
-        self.assertEqual(requests.get(self.url + "/hello", timeout=300).status_code, 200)
-        sleep(2)
-
-        containers = self.docker_client.containers.list(all=True, filters={"label": "sam.cli.container.type=lambda"})
-        initiated_containers = sum(
-            1
-            for c in containers
-            if any(self.mode_env_variable in env for env in c.attrs.get("Config", {}).get("Env", []))
-        )
-        self.assertEqual(initiated_containers, 1)
-
-
-class TestFunctionNameFilteringWarmContainersLazy(StartApiIntegBaseClass):
-    """Test function filtering with LAZY warm containers"""
-
-    template_path = "/testdata/start_api/template-warm-containers.yaml"
-    container_mode = ContainersInitializationMode.LAZY.value
-    mode_env_variable = str(uuid.uuid4())
-    parameter_overrides = {"ModeEnvVariable": mode_env_variable}
-
-    @classmethod
-    def setUpClass(cls):
-        cls.command_list = [
-            get_sam_command(),
-            "local",
-            "start-api",
-            "HelloWorldFunction",
-            "-t",
-            cls.integration_dir + cls.template_path,
-            "--warm-containers",
-            cls.container_mode,
-            "--parameter-overrides",
-            cls._make_parameter_override_arg(cls.parameter_overrides),
-        ]
-        super().setUpClass()
-
-    def setUp(self):
-        self.url = f"http://127.0.0.1:{self.port}"
-
-    def _count_containers(self):
-        """Count containers with the test's unique environment variable"""
-        containers = self.docker_client.containers.list(all=True, filters={"label": "sam.cli.container.type=lambda"})
-        return sum(
-            1
-            for c in containers
-            if any(self.mode_env_variable in env for env in c.attrs.get("Config", {}).get("Env", []))
-        )
-
-    @pytest.mark.flaky(reruns=3)
-    @pytest.mark.timeout(timeout=600, method="thread")
-    def test_container_created_on_demand_for_filtered_function(self):
-        """Test that containers are created on-demand only for filtered functions in LAZY mode"""
-        initial_count = self._count_containers()
-        self.assertEqual(requests.get(self.url + "/hello", timeout=300).status_code, 200)
-        sleep(2)
-        self.assertEqual(self._count_containers() - initial_count, 1)