feat: S3 feature_ check

docker/docker-frontend.sh

@@ -19,6 +19,7 @@ set -e
 
 # Packages needed for puppeteer:
 apt update
+chmod -R 777 /root
 if [ "$PUPPETEER_SKIP_CHROMIUM_DOWNLOAD" = "false" ]; then
     apt install -y chromium
 fi

docker/pythonpath_dev/superset_config.py

@@ -100,6 +100,13 @@ class CeleryConfig:
 
 SQLLAB_CTAS_NO_LIMIT = True
 
+# AWS S3 reporting - uncomment to use
+FEATURE_FLAGS = {"ALERT_REPORTS": True, "ENABLE_AWS": True}
+ALERT_REPORTS_NOTIFICATION_DRY_RUN = False
+# AWS Credentials
+AWS_ACCESS_KEY = "####"
+AWS_SECRET_KEY = "####"
+
 #
 # Optionally import superset_config_docker.py (which will have been included on
 # the PYTHONPATH) in order to allow for local settings to be overridden

superset/commands/base.py

@@ -58,7 +58,7 @@ def populate_owners(owner_ids: Optional[list[int]] = None) -> list[User]:
         return populate_owner_list(owner_ids, default_to_user=True)
 
 
-class UpdateMixin:  # pylint: disable=too-few-public-methods
+class UpdateMixin:
     @staticmethod
     def populate_owners(owner_ids: Optional[list[int]] = None) -> list[User]:
         """

superset/commands/report/execute.py

@@ -64,7 +64,7 @@
     ReportState,
 )
 from superset.reports.notifications import create_notification
-from superset.reports.notifications.base import NotificationContent
+from superset.reports.notifications.base import AwsConfiguration, NotificationContent
 from superset.reports.notifications.exceptions import NotificationError
 from superset.tasks.utils import get_executor
 from superset.utils.core import HeaderDataType, override_user
@@ -396,6 +396,15 @@ def _get_notification_content(self) -> NotificationContent:
             header_data=header_data,
         )
 
+    def _get_aws_configuration(self) -> AwsConfiguration:
+        aws_key = self._report_schedule.aws_key
+        aws_secret_key = self._report_schedule.aws_secret_key
+        aws_s3_types = self._report_schedule.aws_s3_types
+
+        return AwsConfiguration(
+            aws_key=aws_key, aws_secret_key=aws_secret_key, aws_s3_types=aws_s3_types
+        )
+
     def _send(
         self,
         notification_content: NotificationContent,
@@ -408,7 +417,13 @@ def _send(
         """
         notification_errors: list[SupersetError] = []
         for recipient in recipients:
-            notification = create_notification(recipient, notification_content)
+            if recipient.type == ReportRecipientType.S3:
+                aws_configuration = self._get_aws_configuration()
+                notification = create_notification(
+                    recipient, notification_content, aws_configuration
+                )
+            else:
+                notification = create_notification(recipient, notification_content)
             try:
                 if app.config["ALERT_REPORTS_NOTIFICATION_DRY_RUN"]:
                     logger.info(
@@ -426,9 +441,9 @@ def _send(
                     SupersetError(
                         message=ex.message,
                         error_type=SupersetErrorType.REPORT_NOTIFICATION_ERROR,
-                        level=ErrorLevel.ERROR
-                        if ex.status >= 500
-                        else ErrorLevel.WARNING,
+                        level=(
+                            ErrorLevel.ERROR if ex.status >= 500 else ErrorLevel.WARNING
+                        ),
                     )
                 )
         if notification_errors:

superset/migrations/versions/2024-03-18_15-23_4925b0889720_added_aws_s3_columns_to_reports_model.py

@@ -0,0 +1,53 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""Added AWS S3 columns to reports model
+
+Revision ID: 4925b0889720
+Revises: be1b217cd8cd
+Create Date: 2024-03-18 15:23:10.575512
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = "4925b0889720"
+down_revision = "be1b217cd8cd"
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+from sqlalchemy_utils import EncryptedType
+
+
+def upgrade():
+    op.add_column(
+        "report_schedule",
+        sa.Column("aws_key", EncryptedType(sa.String(1024)), nullable=True),
+    )
+    op.add_column(
+        "report_schedule",
+        sa.Column("aws_secret_key", EncryptedType(sa.String(1024)), nullable=True),
+    )
+    op.add_column(
+        "report_schedule",
+        sa.Column("aws_s3_types", sa.String(length=200), nullable=True),
+    )
+
+
+def downgrade():
+    op.drop_column("report_schedule", "aws_key")
+    op.drop_column("report_schedule", "aws_secret_key")
+    op.drop_column("report_schedule", "aws_s3_types")

superset/reports/api.py

@@ -119,6 +119,9 @@ def ensure_alert_reports_enabled(self) -> Optional[Response]:
         "validator_config_json",
         "validator_type",
         "working_timeout",
+        "aws_secret_key",
+        "aws_key",
+        "aws_s3_types",
     ]
     show_select_columns = show_columns + [
         "chart.datasource_id",
@@ -151,6 +154,9 @@ def ensure_alert_reports_enabled(self) -> Optional[Response]:
         "recipients.type",
         "timezone",
         "type",
+        "aws_secret_key",
+        "aws_key",
+        "aws_s3_types",
     ]
     add_columns = [
         "active",

superset/reports/models.py

@@ -34,7 +34,7 @@
 from sqlalchemy.schema import UniqueConstraint
 from sqlalchemy_utils import UUIDType
 
-from superset.extensions import security_manager
+from superset.extensions import encrypted_field_factory, security_manager
 from superset.models.core import Database
 from superset.models.dashboard import Dashboard
 from superset.models.helpers import AuditMixinNullable, ExtraJSONMixin
@@ -61,6 +61,7 @@ class ReportScheduleValidatorType(StrEnum):
 class ReportRecipientType(StrEnum):
     EMAIL = "Email"
     SLACK = "Slack"
+    S3 = "S3"
 
 
 class ReportState(StrEnum):
@@ -168,7 +169,9 @@ class ReportSchedule(AuditMixinNullable, ExtraJSONMixin, Model):
 
     custom_width = Column(Integer, nullable=True)
     custom_height = Column(Integer, nullable=True)
-
+    aws_key = Column(encrypted_field_factory.create(String(1024)))
+    aws_secret_key = Column(encrypted_field_factory.create(String(1024)))
+    aws_s3_types = Column(String(200))
     extra: ReportScheduleExtra  # type: ignore
 
     def __repr__(self) -> str:

superset/reports/notifications/__init__.py

@@ -15,21 +15,28 @@
 # specific language governing permissions and limitations
 # under the License.
 from superset.reports.models import ReportRecipients
-from superset.reports.notifications.base import BaseNotification, NotificationContent
+from superset.reports.notifications.base import (
+    AwsConfiguration,
+    BaseNotification,
+    NotificationContent,
+)
 from superset.reports.notifications.email import EmailNotification
+from superset.reports.notifications.s3 import S3Notification
 from superset.reports.notifications.slack import SlackNotification
 
 
 def create_notification(
-    recipient: ReportRecipients, notification_content: NotificationContent
+    recipient: ReportRecipients,
+    notification_content: NotificationContent,
+    aws_configuration: AwsConfiguration = None,  # type: ignore
 ) -> BaseNotification:
     """
     Notification polymorphic factory
     Returns the Notification class for the recipient type
     """
     for plugin in BaseNotification.plugins:
         if plugin.type == recipient.type:
-            return plugin(recipient, notification_content)
+            return plugin(recipient, notification_content, aws_configuration)
     raise Exception(  # pylint: disable=broad-exception-raised
         "Recipient type not supported"
     )

superset/reports/notifications/base.py

@@ -35,6 +35,13 @@ class NotificationContent:
     embedded_data: Optional[pd.DataFrame] = None
 
 
+@dataclass
+class AwsConfiguration:
+    aws_key: Optional[str] = None
+    aws_secret_key: Optional[str] = None
+    aws_s3_types: Optional[str] = None
+
+
 class BaseNotification:  # pylint: disable=too-few-public-methods
     """
     Serves has base for all notifications and creates a simple plugin system
@@ -55,10 +62,14 @@ def __init_subclass__(cls, *args: Any, **kwargs: Any) -> None:
         cls.plugins.append(cls)
 
     def __init__(
-        self, recipient: ReportRecipients, content: NotificationContent
+        self,
+        recipient: ReportRecipients,
+        content: NotificationContent,
+        aws_configuration: AwsConfiguration = None,  # type: ignore
     ) -> None:
         self._recipient = recipient
         self._content = content
+        self._aws_configuration = aws_configuration
 
     def send(self) -> None:
         raise NotImplementedError()

superset/reports/notifications/s3.py

@@ -0,0 +1,145 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+import datetime
+import json
+import logging
+from io import BytesIO
+from typing import Any, Optional
+from uuid import uuid4
+
+import boto3
+
+from superset import app
+from superset.exceptions import SupersetErrorsException
+from superset.reports.models import ReportRecipientType
+from superset.reports.notifications.base import BaseNotification
+from superset.reports.notifications.exceptions import NotificationError
+
+logger = logging.getLogger(__name__)
+
+
+class S3SubTypes:  # pylint: disable=too-few-public-methods
+    """
+    Defines different types of AWS S3 configurations.
+    """
+
+    S3_CRED = "AWS_S3_credentials"
+    S3_CONFIG = "AWS_S3_pyconfig"
+    S3_ROLE = "AWS_S3_IAM"
+
+
+class S3Notification(BaseNotification):  # pylint: disable=too-few-public-methods
+    # pylint: disable= too-many-arguments, invalid-name
+    type = ReportRecipientType.S3
+
+    def _get_inline_files(self) -> dict[Any, Any]:
+        current_datetime = datetime.datetime.now()
+        formatted_date = current_datetime.strftime("%Y-%m-%d")
+        report_name = self._content.name
+        name_prefix = f"{report_name}/{formatted_date}/"
+
+        if self._content.csv:
+            data = {
+                f"{name_prefix}{report_name}-{str(uuid4())[:8]}.csv": self._content.csv
+            }
+            return data
+        if self._content.screenshots:
+            images = {
+                f"{name_prefix}Screenshot-{str(uuid4())[:8]}.png": screenshot
+                for screenshot in self._content.screenshots
+            }
+            return images
+        return {}
+
+    def _execute_s3_upload(
+        self,
+        file_body: dict[Any, Any],
+        bucket_name: str,
+        content_type: str,
+        aws_access_key_id: Optional[str] = None,
+        aws_secret_access_key: Optional[str] = None,
+    ) -> None:
+        for key, file in file_body.items():
+            file = BytesIO(file)
+            s3 = boto3.client(
+                "s3",
+                aws_access_key_id=aws_access_key_id,
+                aws_secret_access_key=aws_secret_access_key,
+            )
+            s3.upload_fileobj(
+                file,
+                bucket_name,
+                key,
+                ExtraArgs={
+                    "Metadata": {"Content-Disposition": "inline"},
+                    "content_type": content_type,
+                },
+            )
+
+            logger.info(
+                "Report sent to Aws S3 Bucket, notification content is %s",
+                self._content.header_data,
+            )
+
+    def send(self) -> None:
+        files = self._get_inline_files()
+        file_type = "csv" if self._content.csv else "png"
+        bucket_name = json.loads(self._recipient.recipient_config_json)["target"]
+        s3_subtype = self._aws_configuration.aws_s3_types
+
+        try:
+            if s3_subtype == S3SubTypes.S3_CRED:
+                aws_access_key_id = self._aws_configuration.aws_key
+                aws_secret_access_key = self._aws_configuration.aws_secret_key
+
+                self._execute_s3_upload(
+                    file_body=files,
+                    bucket_name=bucket_name,
+                    content_type=file_type,
+                    aws_access_key_id=aws_access_key_id,
+                    aws_secret_access_key=aws_secret_access_key,
+                )
+
+            elif s3_subtype == S3SubTypes.S3_ROLE:
+                self._execute_s3_upload(
+                    file_body=files, bucket_name=bucket_name, content_type=file_type
+                )
+
+            elif s3_subtype == S3SubTypes.S3_CONFIG:
+                aws_access_key_id = app.config["AWS_ACCESS_KEY"]
+                aws_secret_access_key = app.config["AWS_SECRET_KEY"]
+
+                self._execute_s3_upload(
+                    file_body=files,
+                    bucket_name=bucket_name,
+                    content_type=file_type,
+                    aws_access_key_id=aws_access_key_id,
+                    aws_secret_access_key=aws_secret_access_key,
+                )
+            else:
+                msg = (
+                    f"Unsupported AWS S3 method, Must be {S3SubTypes.S3_CONFIG} | "
+                    f"{S3SubTypes.S3_CRED} | {S3SubTypes.S3_ROLE}"
+                )
+
+                logger.error(msg)
+        except SupersetErrorsException as ex:
+            raise NotificationError(
+                ";".join([error.message for error in ex.errors])
+            ) from ex
+        except Exception as ex:
+            raise NotificationError(str(ex)) from ex

superset/reports/schemas.py

@@ -30,6 +30,7 @@
     ReportScheduleType,
     ReportScheduleValidatorType,
 )
+from superset.reports.notifications.s3 import S3SubTypes
 
 openapi_spec_methods_override = {
     "get": {"get": {"summary": "Get a report schedule"}},
@@ -211,6 +212,9 @@ class ReportSchedulePostSchema(Schema):
         dump_default=None,
     )
     force_screenshot = fields.Boolean(dump_default=False)
+    aws_key = fields.String(default=None, missing=None)
+    aws_secret_key = fields.String(default=None, missing=None)
+    aws_s3_types = fields.String(default=None, missing=None)
     custom_width = fields.Integer(
         metadata={
             "description": _("Custom width of the screenshot in pixels"),
@@ -252,6 +256,32 @@ def validate_report_references(  # pylint: disable=unused-argument
                     {"database": ["Database reference is not allowed on a report"]}
                 )
 
+    @validates_schema
+    def validate_aws_fields(  # pylint: disable=unused-argument
+        self,
+        data: dict[str, Any],
+        **kwargs: Any,
+    ) -> None:
+        if (
+            data["recipients"][0]["type"] == ReportRecipientType.S3
+            and data["aws_s3_types"] not in vars(S3SubTypes).values()
+        ):
+            raise ValidationError(
+                {"aws s3 types": ["Not a supported aws s3 sub types"]}
+            )
+        if (
+            data["recipients"][0]["type"] == ReportRecipientType.S3
+            and data["aws_s3_types"] == S3SubTypes.S3_CRED
+        ):
+            if data["aws_key"] is None or data["aws_secret_key"] is None:
+                raise ValidationError(
+                    {
+                        "aws credentials": [
+                            "Both AWS keys and Aws secret keys are required"
+                        ]
+                    }
+                )
+
 
 class ReportSchedulePutSchema(Schema):
     type = fields.String(
@@ -350,6 +380,9 @@ class ReportSchedulePutSchema(Schema):
         required=False,
         default=None,
     )
+    aws_key = fields.String(default=None, missing=None)
+    aws_secret_key = fields.String(default=None, missing=None)
+    aws_s3_types = fields.String(default=None, missing=None)
 
     @validates("custom_width")
     def validate_custom_width(

superset/views/base.py

@@ -391,16 +391,21 @@ def cached_common_bootstrap_data(  # pylint: disable=unused-argument
         for k in FRONTEND_CONF_KEYS
     }
 
-    if conf.get("SLACK_API_TOKEN"):
-        frontend_config["ALERT_REPORTS_NOTIFICATION_METHODS"] = [
-            ReportRecipientType.EMAIL,
-            ReportRecipientType.SLACK,
-        ]
-    else:
-        frontend_config["ALERT_REPORTS_NOTIFICATION_METHODS"] = [
-            ReportRecipientType.EMAIL,
-        ]
+    is_aws_configured = (
+        get_feature_flags()["ENABLE_AWS"]
+        if "ENABLE_AWS" in get_feature_flags()
+        else False
+    )
 
+    frontend_config["ALERT_REPORTS_NOTIFICATION_METHODS"] = [ReportRecipientType.EMAIL]
+    if conf.get("SLACK_API_TOKEN"):
+        frontend_config["ALERT_REPORTS_NOTIFICATION_METHODS"].append(
+            ReportRecipientType.SLACK
+        )
+    if is_aws_configured:
+        frontend_config["ALERT_REPORTS_NOTIFICATION_METHODS"].append(
+            ReportRecipientType.S3
+        )
     # verify client has google sheets installed
     available_specs = get_available_engine_specs()
     frontend_config["HAS_GSHEETS_INSTALLED"] = bool(available_specs[GSheetsEngineSpec])

tests/integration_tests/base_tests.py

@@ -85,6 +85,7 @@ def post_assert_metric(
     with patch.object(
         BaseSupersetModelRestApi, "incr_stats", return_value=None
     ) as mock_method:
+        print("The data is of payload>>>>>>>>>>>>>>>>>>", data)
         rv = client.post(uri, json=data)
     if 200 <= rv.status_code < 400:
         mock_method.assert_called_once_with("success", func_name)

tests/integration_tests/reports/api_tests.py

@@ -350,6 +350,9 @@ def test_get_list_report_schedule(self):
 
         expected_fields = [
             "active",
+            "aws_key",
+            "aws_s3_types",
+            "aws_secret_key",
             "changed_by",
             "changed_on",
             "changed_on_delta_humanized",
@@ -641,6 +644,16 @@ def test_create_report_schedule_uniqueness(self):
             "crontab": "0 9 * * *",
             "chart": chart.id,
             "database": example_db.id,
+            "recipients": [
+                {
+                    "type": ReportRecipientType.EMAIL,
+                    "recipient_config_json": {"target": "target@superset.org"},
+                },
+                {
+                    "type": ReportRecipientType.SLACK,
+                    "recipient_config_json": {"target": "channel"},
+                },
+            ],
         }
         uri = "api/v1/report/"
         rv = self.post_assert_metric(uri, report_schedule_data, "post")
@@ -656,6 +669,16 @@ def test_create_report_schedule_uniqueness(self):
             "crontab": "0 9 * * *",
             "creation_method": ReportCreationMethod.ALERTS_REPORTS,
             "chart": chart.id,
+            "recipients": [
+                {
+                    "type": ReportRecipientType.EMAIL,
+                    "recipient_config_json": {"target": "target@superset.org"},
+                },
+                {
+                    "type": ReportRecipientType.SLACK,
+                    "recipient_config_json": {"target": "channel"},
+                },
+            ],
         }
         uri = "api/v1/report/"
         rv = self.client.post(uri, json=report_schedule_data)
@@ -688,6 +711,16 @@ def test_create_report_schedule_schema(self):
             "crontab": "0 9 * * *",
             "chart": chart.id,
             "database": example_db.id,
+            "recipients": [
+                {
+                    "type": ReportRecipientType.EMAIL,
+                    "recipient_config_json": {"target": "target@superset.org"},
+                },
+                {
+                    "type": ReportRecipientType.SLACK,
+                    "recipient_config_json": {"target": "channel"},
+                },
+            ],
         }
         uri = "api/v1/report/"
         rv = self.post_assert_metric(uri, report_schedule_data, "post")
@@ -925,6 +958,16 @@ def test_unsaved_report_schedule_schema(self):
             "creation_method": ReportCreationMethod.CHARTS,
             "crontab": "0 9 * * *",
             "chart": 0,
+            "recipients": [
+                {
+                    "type": ReportRecipientType.EMAIL,
+                    "recipient_config_json": {"target": "target@superset.org"},
+                },
+                {
+                    "type": ReportRecipientType.SLACK,
+                    "recipient_config_json": {"target": "channel"},
+                },
+            ],
         }
         uri = "api/v1/report/"
         rv = self.post_assert_metric(uri, report_schedule_data, "post")
@@ -952,6 +995,16 @@ def test_no_dashboard_report_schedule_schema(self):
             "description": "description",
             "creation_method": ReportCreationMethod.DASHBOARDS,
             "crontab": "0 9 * * *",
+            "recipients": [
+                {
+                    "type": ReportRecipientType.EMAIL,
+                    "recipient_config_json": {"target": "target@superset.org"},
+                },
+                {
+                    "type": ReportRecipientType.SLACK,
+                    "recipient_config_json": {"target": "channel"},
+                },
+            ],
         }
         uri = "api/v1/report/"
         rv = self.post_assert_metric(uri, report_schedule_data, "post")
@@ -981,6 +1034,16 @@ def test_create_multiple_creation_method_report_schedule_charts(self):
             "crontab": "0 9 * * *",
             "working_timeout": 3600,
             "chart": chart.id,
+            "recipients": [
+                {
+                    "type": ReportRecipientType.EMAIL,
+                    "recipient_config_json": {"target": "target@superset.org"},
+                },
+                {
+                    "type": ReportRecipientType.SLACK,
+                    "recipient_config_json": {"target": "channel"},
+                },
+            ],
         }
         uri = "api/v1/report/"
         rv = self.post_assert_metric(uri, report_schedule_data, "post")
@@ -997,6 +1060,16 @@ def test_create_multiple_creation_method_report_schedule_charts(self):
             "crontab": "0 9 * * *",
             "working_timeout": 3600,
             "chart": chart.id,
+            "recipients": [
+                {
+                    "type": ReportRecipientType.EMAIL,
+                    "recipient_config_json": {"target": "target@superset.org"},
+                },
+                {
+                    "type": ReportRecipientType.SLACK,
+                    "recipient_config_json": {"target": "channel"},
+                },
+            ],
         }
         uri = "api/v1/report/"
         rv = self.post_assert_metric(uri, report_schedule_data, "post")
@@ -1039,6 +1112,16 @@ def test_create_multiple_creation_method_report_schedule_dashboards(self):
             "crontab": "0 9 * * *",
             "working_timeout": 3600,
             "dashboard": dashboard.id,
+            "recipients": [
+                {
+                    "type": ReportRecipientType.EMAIL,
+                    "recipient_config_json": {"target": "target@superset.org"},
+                },
+                {
+                    "type": ReportRecipientType.SLACK,
+                    "recipient_config_json": {"target": "channel"},
+                },
+            ],
         }
         uri = "api/v1/report/"
         rv = self.post_assert_metric(uri, report_schedule_data, "post")
@@ -1055,6 +1138,16 @@ def test_create_multiple_creation_method_report_schedule_dashboards(self):
             "crontab": "0 9 * * *",
             "working_timeout": 3600,
             "dashboard": dashboard.id,
+            "recipients": [
+                {
+                    "type": ReportRecipientType.EMAIL,
+                    "recipient_config_json": {"target": "target@superset.org"},
+                },
+                {
+                    "type": ReportRecipientType.SLACK,
+                    "recipient_config_json": {"target": "channel"},
+                },
+            ],
         }
         uri = "api/v1/report/"
         rv = self.post_assert_metric(uri, report_schedule_data, "post")
@@ -1098,6 +1191,16 @@ def test_create_report_schedule_chart_dash_validation(self):
             "chart": chart.id,
             "dashboard": dashboard.id,
             "database": example_db.id,
+            "recipients": [
+                {
+                    "type": ReportRecipientType.EMAIL,
+                    "recipient_config_json": {"target": "target@superset.org"},
+                },
+                {
+                    "type": ReportRecipientType.SLACK,
+                    "recipient_config_json": {"target": "channel"},
+                },
+            ],
         }
         uri = "api/v1/report/"
         rv = self.post_assert_metric(uri, report_schedule_data, "post")
@@ -1121,6 +1224,16 @@ def test_create_report_schedule_chart_db_validation(self):
             "creation_method": ReportCreationMethod.ALERTS_REPORTS,
             "crontab": "0 9 * * *",
             "chart": chart.id,
+            "recipients": [
+                {
+                    "type": ReportRecipientType.EMAIL,
+                    "recipient_config_json": {"target": "target@superset.org"},
+                },
+                {
+                    "type": ReportRecipientType.SLACK,
+                    "recipient_config_json": {"target": "channel"},
+                },
+            ],
         }
         uri = "api/v1/report/"
         rv = self.post_assert_metric(uri, report_schedule_data, "post")
@@ -1148,6 +1261,16 @@ def test_create_report_schedule_relations_exist(self):
             "crontab": "0 9 * * *",
             "chart": chart_max_id + 1,
             "database": database_max_id + 1,
+            "recipients": [
+                {
+                    "type": ReportRecipientType.EMAIL,
+                    "recipient_config_json": {"target": "target@superset.org"},
+                },
+                {
+                    "type": ReportRecipientType.SLACK,
+                    "recipient_config_json": {"target": "channel"},
+                },
+            ],
         }
         uri = "api/v1/report/"
         rv = self.post_assert_metric(uri, report_schedule_data, "post")
@@ -1170,6 +1293,16 @@ def test_create_report_schedule_relations_exist(self):
             "creation_method": ReportCreationMethod.ALERTS_REPORTS,
             "dashboard": dashboard_max_id + 1,
             "database": examples_db.id,
+            "recipients": [
+                {
+                    "type": ReportRecipientType.EMAIL,
+                    "recipient_config_json": {"target": "target@superset.org"},
+                },
+                {
+                    "type": ReportRecipientType.SLACK,
+                    "recipient_config_json": {"target": "channel"},
+                },
+            ],
         }
         uri = "api/v1/report/"
         rv = self.post_assert_metric(uri, report_schedule_data, "post")

tests/integration_tests/reports/commands_tests.py

@@ -70,6 +70,8 @@
     ReportScheduleType,
     ReportScheduleValidatorType,
     ReportState,
+    ReportRecipients,
+    ReportRecipientType,
 )
 from superset.reports.notifications.exceptions import (
     NotificationError,
@@ -1967,7 +1969,11 @@ def test_prune_log_soft_time_out(bulk_delete_logs, create_report_email_dashboard
 @patch("superset.commands.report.execute.create_notification")
 def test__send_with_client_errors(notification_mock, logger_mock):
     notification_content = "I am some content"
-    recipients = ["test@foo.com"]
+    config_json = {"target": "test@foo.com"}
+    recipients = [ReportRecipients(
+                            type=ReportRecipientType.EMAIL,
+                            recipient_config_json=json.dumps(config_json),
+                        )]
     notification_mock.return_value.send.side_effect = NotificationParamException()
     with pytest.raises(ReportScheduleClientErrorsException) as excinfo:
         BaseReportState._send(BaseReportState, notification_content, recipients)
@@ -1982,7 +1988,11 @@ def test__send_with_client_errors(notification_mock, logger_mock):
 @patch("superset.commands.report.execute.create_notification")
 def test__send_with_multiple_errors(notification_mock, logger_mock):
     notification_content = "I am some content"
-    recipients = ["test@foo.com", "test2@bar.com"]
+    config_json = {"target": "test@foo.com,test2@bar.com"}
+    recipients = [ReportRecipients(
+                            type=ReportRecipientType.EMAIL,
+                            recipient_config_json=json.dumps(config_json),
+                        )]
     notification_mock.return_value.send.side_effect = [
         NotificationParamException(),
         NotificationError(),
@@ -2009,7 +2019,11 @@ def test__send_with_multiple_errors(notification_mock, logger_mock):
 @patch("superset.commands.report.execute.create_notification")
 def test__send_with_server_errors(notification_mock, logger_mock):
     notification_content = "I am some content"
-    recipients = ["test@foo.com"]
+    config_json = {"target": "test@foo.com"}
+    recipients = [ReportRecipients(
+                            type=ReportRecipientType.EMAIL,
+                            recipient_config_json=json.dumps(config_json),
+                        )]
     notification_mock.return_value.send.side_effect = NotificationError()
     with pytest.raises(ReportScheduleSystemErrorsException) as excinfo:
         BaseReportState._send(BaseReportState, notification_content, recipients)

tests/unit_tests/reports/schemas_test.py

@@ -43,6 +43,7 @@ def test_report_post_schema_custom_width_validation(mocker: MockFixture) -> None
             "crontab": "* * * * *",
             "timezone": "America/Los_Angeles",
             "custom_width": 100,
+            "recipients": [{"type": "Email"}],
         }
     )
 
@@ -55,6 +56,7 @@ def test_report_post_schema_custom_width_validation(mocker: MockFixture) -> None
             "active": True,
             "crontab": "* * * * *",
             "timezone": "America/Los_Angeles",
+            "recipients": [{"type": "Email"}],
         }
     )
 
@@ -68,6 +70,60 @@ def test_report_post_schema_custom_width_validation(mocker: MockFixture) -> None
                 "crontab": "* * * * *",
                 "timezone": "America/Los_Angeles",
                 "custom_width": 1000,
+                "recipients": [{"type": "Email"}],
+            }
+        )
+    assert excinfo.value.messages == {
+        "custom_width": ["Screenshot width must be between 100px and 200px"]
+    }
+
+
+def test_report_post_schema_custom_width_validation_with_aws_fields(
+    mocker: MockFixture,
+) -> None:
+    """
+    Test the custom width validation along with AWS fields validation.
+    """
+    current_app = mocker.patch("superset.reports.schemas.current_app")
+    current_app.config = {
+        "ALERT_REPORTS_MIN_CUSTOM_SCREENSHOT_WIDTH": 100,
+        "ALERT_REPORTS_MAX_CUSTOM_SCREENSHOT_WIDTH": 200,
+    }
+    valid_s3_types = ["AWS_S3_credentials", "AWS_S3_pyconfig", "AWS_S3_IAM"]
+    schema = ReportSchedulePostSchema()
+
+    for s3_type in valid_s3_types:
+        # Test with valid AWS credentials and custom_width for each valid S3 type
+        schema.load(
+            {
+                "type": "Report",
+                "name": "A report",
+                "description": "My report",
+                "active": True,
+                "crontab": "* * * * *",
+                "timezone": "America/Los_Angeles",
+                "custom_width": 100,
+                "recipients": [{"type": "S3"}],
+                "aws_key": "valid_key",
+                "aws_secret_key": "valid_secret_key",
+                "aws_s3_types": s3_type,
+            }
+        )
+
+    with pytest.raises(ValidationError) as excinfo:
+        schema.load(
+            {
+                "type": "Report",
+                "name": "A report",
+                "description": "My report",
+                "active": True,
+                "crontab": "* * * * *",
+                "timezone": "America/Los_Angeles",
+                "custom_width": 1000,
+                "recipients": [{"type": "S3"}],
+                "aws_key": "valid_key",
+                "aws_secret_key": "valid_secret_key",
+                "aws_s3_types": s3_type,
             }
         )
     assert excinfo.value.messages == {