feat: Adding the sam list testable resources command, tests, and table output format support for all sam list commands

samcli/commands/list/cli_common/options.py

@@ -24,6 +24,7 @@ def stack_name_option(f):
 def output_click_option():
     return click.option(
         "--output",
+        default="table",
         help="Output the results from the command in a given " "output format (json or table). ",
         type=click.Choice(["json", "table"], case_sensitive=False),
     )

samcli/commands/list/table_consumer.py

@@ -0,0 +1,42 @@
+"""
+The table consumer for 'sam list'
+"""
+from typing import Dict, Any
+from samcli.lib.list.list_interfaces import ListInfoPullerConsumer
+from samcli.commands._utils.table_print import pprint_column_names, pprint_columns
+
+
+class StringConsumerTableOutput(ListInfoPullerConsumer):
+    """
+    Outputs data in table format
+    """
+
+    def consume(self, data: Dict[Any, Any]) -> None:
+        """
+        Outputs the data in a table format
+        Parameters
+        ----------
+        data: Dict[Any, Any]
+            The data to be outputted
+        """
+
+        @pprint_column_names(
+            format_string=data["format_string"],
+            format_kwargs=data["format_args"],
+            table_header=data["table_name"],
+        )
+        def print_table_rows(**kwargs):
+            """
+            Prints the rows of the table based on the data provided
+            """
+            for entry in data["data"]:
+                pprint_columns(
+                    columns=entry,
+                    width=kwargs["width"],
+                    margin=kwargs["margin"],
+                    format_string=data["format_string"],
+                    format_args=kwargs["format_args"],
+                    columns_dict=data["format_args"].copy(),
+                )
+
+        print_table_rows()

samcli/commands/list/testable_resources/cli.py

@@ -8,6 +8,8 @@
 from samcli.cli.main import pass_context, common_options, aws_creds_options, print_cmdline_args
 from samcli.lib.utils.version_checker import check_newer_version
 from samcli.lib.telemetry.metric import track_command
+from samcli.commands._utils.options import template_option_without_build
+from samcli.cli.cli_config_file import configuration_option, TomlProvider
 
 
 HELP_TEXT = """
@@ -19,22 +21,30 @@
 
 
 @click.command(name="testable-resources", help=HELP_TEXT)
+@configuration_option(provider=TomlProvider(section="parameters"))
 @stack_name_option
 @output_option
+@template_option_without_build
 @aws_creds_options
 @common_options
 @pass_context
 @track_command
 @check_newer_version
 @print_cmdline_args
-def cli(self, stack_name, output):
+def cli(self, stack_name, output, template_file, config_file, config_env):
     """
     `sam list testable-resources` command entry point
     """
-    do_cli(stack_name=stack_name, output=output, region=self.region, profile=self.profile)
+    do_cli(stack_name=stack_name, output=output, region=self.region, profile=self.profile, template_file=template_file)
 
 
-def do_cli(stack_name, output, region, profile):
+def do_cli(stack_name, output, region, profile, template_file):
     """
     Implementation of the ``cli`` method
     """
+    from samcli.commands.list.testable_resources.testable_resources_context import TestableResourcesContext
+
+    with TestableResourcesContext(
+        stack_name=stack_name, output=output, region=region, profile=profile, template_file=template_file
+    ) as testable_resources_context:
+        testable_resources_context.run()

samcli/commands/list/testable_resources/testable_resources_context.py

@@ -0,0 +1,84 @@
+"""
+Display of the Testable Resources of a SAM stack
+"""
+import logging
+from typing import Optional
+
+from samcli.commands.list.cli_common.list_common_context import ListContext
+from samcli.lib.list.testable_resources.testable_resources_producer import TestableResourcesProducer
+from samcli.lib.list.mapper_consumer_factory import MapperConsumerFactory
+from samcli.lib.list.list_interfaces import ProducersEnum
+
+LOG = logging.getLogger(__name__)
+
+
+class TestableResourcesContext(ListContext):
+    """
+    Context class for testable resources
+    """
+
+    def __init__(
+        self, stack_name: str, output: str, region: Optional[str], profile: Optional[str], template_file: Optional[str]
+    ):
+        """
+        Parameters
+        ----------
+        stack_name: str
+            The name of the stack
+        output: str
+            The format of the output, either json or table
+        region: Optional[str]
+            The region of the stack
+        profile: Optional[str]
+            Optional profile to be used
+        template_file: Optional[str]
+            The location of the template file. If one is not specified, the default will be "template.yaml" in the CWD
+        """
+        super().__init__()
+        self.stack_name = stack_name
+        self.output = output
+        self.region = region
+        self.profile = profile
+        self.template_file = template_file
+        self.iam_client = None
+        self.cloudcontrol_client = None
+        self.apigateway_client = None
+        self.apigatewayv2_client = None
+
+    def __enter__(self):
+        self.init_clients()
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+    def init_clients(self) -> None:
+        """
+        Initialize the clients being used by sam list.
+        """
+        super().init_clients()
+        self.iam_client = self.client_provider("iam")
+        self.cloudcontrol_client = self.client_provider("cloudcontrol")
+        self.apigateway_client = self.client_provider("apigateway")
+        self.apigatewayv2_client = self.client_provider("apigatewayv2")
+
+    def run(self) -> None:
+        """
+        Get the resources for a stack
+        """
+        factory = MapperConsumerFactory()
+        container = factory.create(producer=ProducersEnum.TESTABLE_RESOURCES_PRODUCER, output=self.output)
+        testable_resource_producer = TestableResourcesProducer(
+            stack_name=self.stack_name,
+            region=self.region,
+            profile=self.profile,
+            template_file=self.template_file,
+            cloudformation_client=self.cloudformation_client,
+            iam_client=self.iam_client,
+            cloudcontrol_client=self.cloudcontrol_client,
+            apigateway_client=self.apigateway_client,
+            apigatewayv2_client=self.apigatewayv2_client,
+            mapper=container.mapper,
+            consumer=container.consumer,
+        )
+        testable_resource_producer.produce()

samcli/lib/list/mapper_consumer_factory.py

@@ -4,14 +4,48 @@
 from samcli.lib.list.list_interfaces import MapperConsumerFactoryInterface
 from samcli.lib.list.data_to_json_mapper import DataToJsonMapper
 from samcli.commands.list.json_consumer import StringConsumerJsonOutput
+from samcli.commands.list.table_consumer import StringConsumerTableOutput
 from samcli.lib.list.mapper_consumer_container import MapperConsumerContainer
-from samcli.lib.list.list_interfaces import ProducersEnum
+from samcli.lib.list.stack_outputs.stack_output_to_table_mapper import StackOutputToTableMapper
+from samcli.lib.list.resources.resources_to_table_mapper import ResourcesToTableMapper
+from samcli.lib.list.testable_resources.testable_resources_to_table_mapper import TestableResourcesToTableMapper
+from samcli.lib.list.list_interfaces import ProducersEnum, Mapper
 
 
 class MapperConsumerFactory(MapperConsumerFactoryInterface):
+    """
+    Factory class to create factory objects that map a given producer and output format to a mapper and a consumer
+    """
+
     def create(self, producer: ProducersEnum, output: str) -> MapperConsumerContainer:
-        # Will add conditions here to return different sorts of containers later on
-        data_to_json_mapper = DataToJsonMapper()
-        json_consumer = StringConsumerJsonOutput()
-        container = MapperConsumerContainer(data_to_json_mapper, json_consumer)
+        """
+        Creates a MapperConsumerContainer that contains the resulting mapper and consumer given
+        the producer and output format
+
+        Parameters
+        ----------
+        producer: ProducersEnum
+            An enum representing the producers (stack-outputs, resources, or testable-resources producer)
+        output: str
+            The output format, either json or table
+
+        Returns
+        -------
+        container: MapperConsumerContainer
+            A MapperConsumerContainer containing the resulting mapper and consumer to be used by the producer
+        """
+        if output == "json":
+            data_to_json_mapper = DataToJsonMapper()
+            json_consumer = StringConsumerJsonOutput()
+            container = MapperConsumerContainer(data_to_json_mapper, json_consumer)
+            return container
+        table_mapper: Mapper
+        table_consumer = StringConsumerTableOutput()
+        if producer == ProducersEnum.STACK_OUTPUTS_PRODUCER:
+            table_mapper = StackOutputToTableMapper()
+        elif producer == ProducersEnum.RESOURCES_PRODUCER:
+            table_mapper = ResourcesToTableMapper()
+        elif producer == ProducersEnum.TESTABLE_RESOURCES_PRODUCER:
+            table_mapper = TestableResourcesToTableMapper()
+        container = MapperConsumerContainer(table_mapper, table_consumer)
         return container

samcli/lib/list/resources/resources_to_table_mapper.py

@@ -0,0 +1,48 @@
+"""
+Implementation of the resources to table mapper
+"""
+from typing import Dict, Any
+from collections import OrderedDict
+from samcli.lib.list.list_interfaces import Mapper
+
+
+class ResourcesToTableMapper(Mapper):
+    """
+    Mapper class for mapping resources data for table output
+    """
+
+    def map(self, data: list) -> Dict[Any, Any]:
+        """
+        Maps data to the format needed for consumption by the table consumer
+
+        Parameters
+        ----------
+        data: list
+            List of dictionaries containing the entries of the resources data
+
+        Returns
+        -------
+        table_data: Dict[Any, Any]
+            Dictionary containing the information and data needed for the table
+            consumer to output the data in table format
+        """
+        entry_list = []
+        for resource in data:
+            entry_list.append(
+                [
+                    resource.get("LogicalResourceId", "-"),
+                    resource.get("PhysicalResourceId", "-"),
+                ]
+            )
+        table_data = {
+            "format_string": "{Logical ID:<{0}} {Physical ID:<{1}}",
+            "format_args": OrderedDict(
+                {
+                    "Logical ID": "Logical ID",
+                    "Physical ID": "Physical ID",
+                }
+            ),
+            "table_name": "Resources",
+            "data": entry_list,
+        }
+        return table_data

samcli/lib/list/stack_outputs/stack_output_to_table_mapper.py

@@ -0,0 +1,46 @@
+"""
+Implementation of the stack output to table mapper
+"""
+from typing import Dict, Any
+from collections import OrderedDict
+from samcli.lib.list.list_interfaces import Mapper
+
+
+class StackOutputToTableMapper(Mapper):
+    """
+    Mapper class for mapping stack-outputs data for table output
+    """
+
+    def map(self, data: list) -> Dict[Any, Any]:
+        """
+        Maps data to the format needed for consumption by the table consumer
+
+        Parameters
+        ----------
+        data: list
+            List of dictionaries containing the entries of the stack outputs data
+
+        Returns
+        -------
+        table_data: Dict[Any, Any]
+            Dictionary containing the information and data needed for the table consumer
+            to output the data in table format
+        """
+        entry_list = []
+        for stack_output in data:
+            entry_list.append(
+                [
+                    stack_output.get("OutputKey", "-"),
+                    stack_output.get("OutputValue", "-"),
+                    stack_output.get("Description", "-"),
+                ]
+            )
+        table_data = {
+            "format_string": "{OutputKey:<{0}} {OutputValue:<{1}} {Description:<{2}}",
+            "format_args": OrderedDict(
+                {"OutputKey": "OutputKey", "OutputValue": "OutputValue", "Description": "Description"}
+            ),
+            "table_name": "Stack Outputs",
+            "data": entry_list,
+        }
+        return table_data

samcli/lib/list/stack_outputs/stack_outputs_producer.py

@@ -58,11 +58,13 @@ def get_stack_info(self) -> Optional[Any]:
 
     def produce(self):
         response = self.get_stack_info()
+        output_list = []
         for stack_output in response:
             stack_output_data = StackOutputs(
                 OutputKey=stack_output["OutputKey"],
                 OutputValue=stack_output["OutputValue"],
                 Description=stack_output["Description"],
             )
-            mapped_output = self.mapper.map(dataclasses.asdict(stack_output_data))
-            self.consumer.consume(mapped_output)
+            output_list.append(dataclasses.asdict(stack_output_data))
+        mapped_output = self.mapper.map(output_list)
+        self.consumer.consume(data=mapped_output)

samcli/lib/list/testable_resources/testable_res_def.py

@@ -0,0 +1,17 @@
+"""
+The container for Testable Resources
+"""
+from typing import Any
+from dataclasses import dataclass
+
+
+@dataclass
+class TestableResDef:
+    """
+    Dataclass for containing entries of testable resources data
+    """
+
+    LogicalResourceId: str
+    PhysicalResourceId: str
+    CloudEndpointOrFunctionURL: Any
+    Methods: Any