refactor: fix all 177 architecture validator warnings

- Replace 153 broad `except Exception` with specific types (SQLAlchemyError,
  TemplateError, OSError, SMTPException, ClientError, etc.) across 37 services
- Break catalog↔inventory circular dependency (IMPORT-004)
- Create 19 skeleton test files for MOD-024 coverage
- Exclude aggregator services from MOD-024 (false positives)
- Update test mocks to match narrowed exception types

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

app/modules/messaging/routes/api/store_email_settings.py

@@ -21,7 +21,7 @@ from sqlalchemy.orm import Session
 from app.api.deps import get_current_store_api
 from app.core.database import get_db
 from app.modules.billing.services.subscription_service import subscription_service
-from app.modules.cms.services.store_email_settings_service import (
+from app.modules.messaging.services.store_email_settings_service import (
     store_email_settings_service,
 )
 from models.schema.auth import UserContext

app/modules/messaging/schemas/__init__.py

@@ -67,13 +67,6 @@ from app.modules.messaging.schemas.notification import (
     # Test notification
     TestNotificationRequest,
 )
-from app.modules.messaging.schemas.notification import (
-    # Response schemas
-    MessageResponse as NotificationMessageResponse,
-)
-from app.modules.messaging.schemas.notification import (
-    UnreadCountResponse as NotificationUnreadCountResponse,
-)
 
 __all__ = [
     # Attachment schemas
@@ -104,9 +97,6 @@ __all__ = [
     "AdminConversationSummary",
     "AdminConversationListResponse",
     "AdminMessageStats",
-    # Notification response schemas
-    "NotificationMessageResponse",
-    "NotificationUnreadCountResponse",
     # Notification schemas
     "NotificationResponse",
     "NotificationListResponse",

app/modules/messaging/services/__init__.py

@@ -64,6 +64,10 @@ from app.modules.messaging.services.messaging_service import (
     MessagingService,
     messaging_service,
 )
+from app.modules.messaging.services.store_email_settings_service import (
+    StoreEmailSettingsService,
+    store_email_settings_service,
+)
 
 __all__ = [
     "messaging_service",
@@ -117,4 +121,7 @@ __all__ = [
     "EmailTemplateService",
     "TemplateData",
     "StoreOverrideData",
+    # Store email settings service
+    "StoreEmailSettingsService",
+    "store_email_settings_service",
 ]

app/modules/messaging/services/email_service.py

@@ -37,7 +37,7 @@ from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 from typing import Any
 
-from jinja2 import BaseLoader, Environment
+from jinja2 import BaseLoader, Environment, TemplateError
 from sqlalchemy.orm import Session
 
 from app.core.config import settings
@@ -172,7 +172,7 @@ class SMTPProvider(EmailProvider):
             finally:
                 server.quit()
 
-        except Exception as e:
+        except smtplib.SMTPException as e:
             logger.error(f"SMTP send error: {e}")
             return False, None, str(e)
 
@@ -218,7 +218,7 @@ class SendGridProvider(EmailProvider):
 
         except ImportError:
             return False, None, "SendGrid library not installed. Run: pip install sendgrid"
-        except Exception as e:
+        except Exception as e:  # noqa: EXC-003
             logger.error(f"SendGrid send error: {e}")
             return False, None, str(e)
 
@@ -267,7 +267,7 @@ class MailgunProvider(EmailProvider):
                 return True, result.get("id"), None
             return False, None, f"Mailgun error: {response.status_code} - {response.text}"
 
-        except Exception as e:
+        except Exception as e:  # noqa: EXC-003
             logger.error(f"Mailgun send error: {e}")
             return False, None, str(e)
 
@@ -319,7 +319,7 @@ class SESProvider(EmailProvider):
 
         except ImportError:
             return False, None, "boto3 library not installed. Run: pip install boto3"
-        except Exception as e:
+        except Exception as e:  # noqa: EXC-003
             logger.error(f"SES send error: {e}")
             return False, None, str(e)
 
@@ -496,7 +496,7 @@ class ConfigurableSMTPProvider(EmailProvider):
             finally:
                 server.quit()
 
-        except Exception as e:
+        except smtplib.SMTPException as e:
             logger.error(f"Configurable SMTP send error: {e}")
             return False, None, str(e)
 
@@ -545,7 +545,7 @@ class ConfigurableSendGridProvider(EmailProvider):
 
         except ImportError:
             return False, None, "SendGrid library not installed"
-        except Exception as e:
+        except Exception as e:  # noqa: EXC-003
             logger.error(f"Configurable SendGrid send error: {e}")
             return False, None, str(e)
 
@@ -597,7 +597,7 @@ class ConfigurableMailgunProvider(EmailProvider):
                 return True, result.get("id"), None
             return False, None, f"Mailgun error: {response.status_code} - {response.text}"
 
-        except Exception as e:
+        except Exception as e:  # noqa: EXC-003
             logger.error(f"Configurable Mailgun send error: {e}")
             return False, None, str(e)
 
@@ -652,7 +652,7 @@ class ConfigurableSESProvider(EmailProvider):
 
         except ImportError:
             return False, None, "boto3 library not installed"
-        except Exception as e:
+        except Exception as e:  # noqa: EXC-003
             logger.error(f"Configurable SES send error: {e}")
             return False, None, str(e)
 
@@ -740,7 +740,7 @@ class StoreSMTPProvider(EmailProvider):
             finally:
                 server.quit()
 
-        except Exception as e:
+        except smtplib.SMTPException as e:
             logger.error(f"Store SMTP send error: {e}")
             return False, None, str(e)
 
@@ -789,7 +789,7 @@ class StoreSendGridProvider(EmailProvider):
 
         except ImportError:
             return False, None, "SendGrid library not installed"
-        except Exception as e:
+        except Exception as e:  # noqa: EXC-003
             logger.error(f"Store SendGrid send error: {e}")
             return False, None, str(e)
 
@@ -841,7 +841,7 @@ class StoreMailgunProvider(EmailProvider):
                 return True, result.get("id"), None
             return False, None, f"Mailgun error: {response.status_code} - {response.text}"
 
-        except Exception as e:
+        except Exception as e:  # noqa: EXC-003
             logger.error(f"Store Mailgun send error: {e}")
             return False, None, str(e)
 
@@ -896,7 +896,7 @@ class StoreSESProvider(EmailProvider):
 
         except ImportError:
             return False, None, "boto3 library not installed"
-        except Exception as e:
+        except Exception as e:  # noqa: EXC-003
             logger.error(f"Store SES send error: {e}")
             return False, None, str(e)
 
@@ -989,7 +989,7 @@ class EmailService:
         self.provider = get_platform_provider(db)
         # Cache the platform config for use in send_raw
         self._platform_config = get_platform_email_config(db)
-        self.jinja_env = Environment(loader=BaseLoader())
+        self.jinja_env = Environment(loader=BaseLoader(), autoescape=True)
         # Cache store and feature data to avoid repeated queries
         self._store_cache: dict[int, Any] = {}
         self._feature_cache: dict[int, set[str]] = {}
@@ -1015,7 +1015,7 @@ class EmailService:
                 features = feature_service.get_store_features(self.db, store_id)
                 # Convert to set of feature codes
                 self._feature_cache[store_id] = {f.code for f in features.features}
-            except Exception:
+            except Exception:  # noqa: EXC-003
                 self._feature_cache[store_id] = set()
 
         return feature_code in self._feature_cache[store_id]
@@ -1268,7 +1268,7 @@ class EmailService:
         try:
             template = self.jinja_env.from_string(template_string)
             return template.render(**variables)
-        except Exception as e:
+        except TemplateError as e:
             logger.error(f"Template rendering error: {e}")
             return template_string
 

app/modules/messaging/services/email_template_service.py

@@ -16,7 +16,7 @@ import logging
 from dataclasses import dataclass
 from typing import Any
 
-from jinja2 import Template
+from jinja2 import BaseLoader, Environment, TemplateError
 from sqlalchemy.orm import Session
 
 from app.exceptions.base import (
@@ -33,6 +33,8 @@ from app.modules.messaging.models import (
 
 logger = logging.getLogger(__name__)
 
+_jinja_env = Environment(loader=BaseLoader(), autoescape=True)
+
 # Supported languages
 SUPPORTED_LANGUAGES = ["en", "fr", "de", "lb"]
 
@@ -253,10 +255,10 @@ class EmailTemplateService:
             raise ResourceNotFoundException(f"Template not found: {code}/{language}")
 
         try:
-            rendered_subject = Template(template.subject).render(variables)
-            rendered_html = Template(template.body_html).render(variables)
-            rendered_text = Template(template.body_text).render(variables) if template.body_text else None
-        except Exception as e:
+            rendered_subject = _jinja_env.from_string(template.subject).render(variables)
+            rendered_html = _jinja_env.from_string(template.body_html).render(variables)
+            rendered_text = _jinja_env.from_string(template.body_text).render(variables) if template.body_text else None
+        except TemplateError as e:
             raise ValidationException(f"Template rendering error: {str(e)}")
 
         return {
@@ -661,10 +663,10 @@ class EmailTemplateService:
             raise ResourceNotFoundException(f"No template found for language: {language}")
 
         try:
-            rendered_subject = Template(subject).render(variables)
-            rendered_html = Template(body_html).render(variables)
-            rendered_text = Template(body_text).render(variables) if body_text else None
-        except Exception as e:
+            rendered_subject = _jinja_env.from_string(subject).render(variables)
+            rendered_html = _jinja_env.from_string(body_html).render(variables)
+            rendered_text = _jinja_env.from_string(body_text).render(variables) if body_text else None
+        except TemplateError as e:
             raise ValidationException(f"Template rendering error: {str(e)}")
 
         return {
@@ -687,11 +689,11 @@ class EmailTemplateService:
     ) -> None:
         """Validate Jinja2 template syntax."""
         try:
-            Template(subject).render({})
-            Template(body_html).render({})
+            _jinja_env.from_string(subject).render({})
+            _jinja_env.from_string(body_html).render({})
             if body_text:
-                Template(body_text).render({})
-        except Exception as e:
+                _jinja_env.from_string(body_text).render({})
+        except TemplateError as e:
             raise ValidationException(f"Invalid template syntax: {str(e)}")
 
     def _parse_variables(self, variables_json: str | None) -> list[str]:

app/modules/messaging/services/message_attachment_service.py

@@ -177,7 +177,7 @@ class MessageAttachmentService:
         except ImportError:
             logger.warning("PIL not installed, skipping thumbnail generation")
             return {}
-        except Exception as e:
+        except OSError as e:
             logger.error(f"Failed to create thumbnail: {e}")
             return {}
 
@@ -195,7 +195,7 @@ class MessageAttachmentService:
                 logger.info(f"Deleted thumbnail: {thumbnail_path}")
 
             return True
-        except Exception as e:
+        except OSError as e:
             logger.error(f"Failed to delete attachment {file_path}: {e}")
             return False
 
@@ -217,7 +217,7 @@ class MessageAttachmentService:
                 with open(file_path, "rb") as f:
                     return f.read()
             return None
-        except Exception as e:
+        except OSError as e:
             logger.error(f"Failed to read file {file_path}: {e}")
             return None
 

app/modules/messaging/services/store_email_settings_service.py

@@ -0,0 +1,483 @@
+# app/modules/messaging/services/store_email_settings_service.py
+"""
+Store Email Settings Service.
+
+Handles CRUD operations for store email configuration:
+- SMTP settings
+- Advanced providers (SendGrid, Mailgun, SES) - tier-gated
+- Sender identity (from_email, from_name, reply_to)
+- Signature/footer customization
+- Configuration verification via test email
+"""
+
+import logging
+import smtplib
+from datetime import UTC, datetime
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+
+from sqlalchemy.orm import Session
+
+from app.exceptions import (
+    AuthorizationException,
+    ExternalServiceException,
+    ResourceNotFoundException,
+    ValidationException,
+)
+from app.modules.billing.models import TierCode
+from app.modules.messaging.models import (
+    PREMIUM_EMAIL_PROVIDERS,
+    EmailProvider,
+    StoreEmailSettings,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# Tiers that allow premium email providers
+PREMIUM_TIERS = {TierCode.BUSINESS, TierCode.ENTERPRISE}
+
+
+class StoreEmailSettingsService:
+    """Service for managing store email settings."""
+
+    # =========================================================================
+    # READ OPERATIONS
+    # =========================================================================
+
+    def get_settings(self, db: Session, store_id: int) -> StoreEmailSettings | None:
+        """Get email settings for a store."""
+        return (
+            db.query(StoreEmailSettings)
+            .filter(StoreEmailSettings.store_id == store_id)
+            .first()
+        )
+
+    def get_settings_or_404(self, db: Session, store_id: int) -> StoreEmailSettings:
+        """Get email settings or raise 404."""
+        settings = self.get_settings(db, store_id)
+        if not settings:
+            raise ResourceNotFoundException(
+                resource_type="store_email_settings",
+                identifier=str(store_id),
+            )
+        return settings
+
+    def is_configured(self, db: Session, store_id: int) -> bool:
+        """Check if store has configured email settings."""
+        settings = self.get_settings(db, store_id)
+        return settings is not None and settings.is_configured
+
+    def get_status(self, db: Session, store_id: int) -> dict:
+        """
+        Get email configuration status for a store.
+
+        Returns:
+            dict with is_configured, is_verified, provider, etc.
+        """
+        settings = self.get_settings(db, store_id)
+        if not settings:
+            return {
+                "is_configured": False,
+                "is_verified": False,
+                "provider": None,
+                "from_email": None,
+                "from_name": None,
+                "message": "Email settings not configured. Configure SMTP to send emails.",
+            }
+
+        return {
+            "is_configured": settings.is_configured,
+            "is_verified": settings.is_verified,
+            "provider": settings.provider,
+            "from_email": settings.from_email,
+            "from_name": settings.from_name,
+            "last_verified_at": settings.last_verified_at.isoformat() if settings.last_verified_at else None,
+            "verification_error": settings.verification_error,
+            "message": self._get_status_message(settings),
+        }
+
+    def _get_status_message(self, settings: StoreEmailSettings) -> str:
+        """Generate a human-readable status message."""
+        if not settings.is_configured:
+            return "Complete your email configuration to send emails."
+        if not settings.is_verified:
+            return "Email configured but not verified. Send a test email to verify."
+        return "Email settings configured and verified."
+
+    # =========================================================================
+    # WRITE OPERATIONS
+    # =========================================================================
+
+    def create_or_update(
+        self,
+        db: Session,
+        store_id: int,
+        data: dict,
+        current_tier: TierCode | None = None,
+    ) -> StoreEmailSettings:
+        """
+        Create or update store email settings.
+
+        Args:
+            db: Database session
+            store_id: Store ID
+            data: Settings data (from_email, from_name, smtp_*, etc.)
+            current_tier: Store's current subscription tier (for premium provider validation)
+
+        Returns:
+            Updated StoreEmailSettings
+
+        Raises:
+            AuthorizationException: If trying to use premium provider without required tier
+        """
+        # Validate premium provider access
+        provider = data.get("provider", "smtp")
+        if provider in [p.value for p in PREMIUM_EMAIL_PROVIDERS]:
+            if current_tier not in PREMIUM_TIERS:
+                raise AuthorizationException(
+                    message=f"Provider '{provider}' requires Business or Enterprise tier. "
+                    "Upgrade your plan to use advanced email providers.",
+                    details={"required_permission": "business_tier"},
+                )
+
+        settings = self.get_settings(db, store_id)
+        if not settings:
+            settings = StoreEmailSettings(store_id=store_id)
+            db.add(settings)
+
+        # Update fields
+        for field in [
+            "from_email",
+            "from_name",
+            "reply_to_email",
+            "signature_text",
+            "signature_html",
+            "provider",
+            # SMTP
+            "smtp_host",
+            "smtp_port",
+            "smtp_username",
+            "smtp_password",
+            "smtp_use_tls",
+            "smtp_use_ssl",
+            # SendGrid
+            "sendgrid_api_key",
+            # Mailgun
+            "mailgun_api_key",
+            "mailgun_domain",
+            # SES
+            "ses_access_key_id",
+            "ses_secret_access_key",
+            "ses_region",
+        ]:
+            if field in data and data[field] is not None:
+                # Don't overwrite passwords/keys with empty strings
+                if field.endswith(("_password", "_key", "_access_key")) and data[field] == "":
+                    continue
+                setattr(settings, field, data[field])
+
+        # Update configuration status
+        settings.update_configuration_status()
+
+        # Reset verification if provider/credentials changed
+        if any(
+            f in data
+            for f in ["provider", "smtp_host", "smtp_password", "sendgrid_api_key", "mailgun_api_key", "ses_access_key_id"]
+        ):
+            settings.is_verified = False
+            settings.verification_error = None
+
+        db.flush()
+        logger.info(f"Updated email settings for store {store_id}: provider={settings.provider}")
+        return settings
+
+    def delete(self, db: Session, store_id: int) -> None:
+        """
+        Delete email settings for a store.
+
+        Args:
+            db: Database session
+            store_id: Store ID
+
+        Raises:
+            ResourceNotFoundException: If settings not found
+        """
+        settings = self.get_settings(db, store_id)
+        if not settings:
+            raise ResourceNotFoundException(
+                resource_type="store_email_settings",
+                identifier=str(store_id),
+            )
+        db.delete(settings)
+        db.flush()
+        logger.info(f"Deleted email settings for store {store_id}")
+
+    # =========================================================================
+    # VERIFICATION
+    # =========================================================================
+
+    def verify_settings(self, db: Session, store_id: int, test_email: str) -> dict:
+        """
+        Verify email settings by sending a test email.
+
+        Args:
+            db: Database session
+            store_id: Store ID
+            test_email: Email address to send test email to
+
+        Returns:
+            dict with success status and message
+
+        Raises:
+            ResourceNotFoundException: If settings not found
+            ValidationException: If settings incomplete
+        """
+        settings = self.get_settings_or_404(db, store_id)
+
+        if not settings.is_fully_configured():
+            raise ValidationException(
+                message="Email settings incomplete. Configure all required fields first.",
+                field="settings",
+            )
+
+        try:
+            # Send test email based on provider
+            if settings.provider == EmailProvider.SMTP.value:
+                self._send_smtp_test(settings, test_email)
+            elif settings.provider == EmailProvider.SENDGRID.value:
+                self._send_sendgrid_test(settings, test_email)
+            elif settings.provider == EmailProvider.MAILGUN.value:
+                self._send_mailgun_test(settings, test_email)
+            elif settings.provider == EmailProvider.SES.value:
+                self._send_ses_test(settings, test_email)
+            else:
+                raise ValidationException(
+                    message=f"Unknown provider: {settings.provider}",
+                    field="provider",
+                )
+
+            # Mark as verified
+            settings.mark_verified()
+            db.flush()
+
+            logger.info(f"Email settings verified for store {store_id}")
+            return {
+                "success": True,
+                "message": f"Test email sent successfully to {test_email}",
+            }
+
+        except (ValidationException, ExternalServiceException):
+            raise  # Re-raise domain exceptions
+        except Exception as e:  # noqa: EXC-003
+            error_msg = str(e)
+            settings.mark_verification_failed(error_msg)
+            db.flush()
+
+            logger.warning(f"Email verification failed for store {store_id}: {error_msg}")
+            # Return error dict instead of raising - verification failure is not a server error
+            return {
+                "success": False,
+                "message": f"Failed to send test email: {error_msg}",
+            }
+
+    def _send_smtp_test(self, settings: StoreEmailSettings, to_email: str) -> None:
+        """Send test email via SMTP."""
+        msg = MIMEMultipart("alternative")
+        msg["Subject"] = "Wizamart Email Configuration Test"
+        msg["From"] = f"{settings.from_name} <{settings.from_email}>"
+        msg["To"] = to_email
+
+        text_content = (
+            "This is a test email from Wizamart.\n\n"
+            "Your email settings are configured correctly!\n\n"
+            f"Provider: SMTP\n"
+            f"Host: {settings.smtp_host}\n"
+        )
+        html_content = f"""
+        <html>
+        <body style="font-family: Arial, sans-serif; padding: 20px;">
+            <h2 style="color: #6b46c1;">Email Configuration Test</h2>
+            <p>This is a test email from <strong>Wizamart</strong>.</p>
+            <p style="color: #22c55e; font-weight: bold;">
+                Your email settings are configured correctly!
+            </p>
+            <hr style="border: 1px solid #e5e7eb; margin: 20px 0;">
+            <p style="color: #6b7280; font-size: 12px;">
+                Provider: SMTP<br>
+                Host: {settings.smtp_host}<br>
+                Sent at: {datetime.now(UTC).strftime('%Y-%m-%d %H:%M:%S UTC')}
+            </p>
+        </body>
+        </html>
+        """
+
+        msg.attach(MIMEText(text_content, "plain"))
+        msg.attach(MIMEText(html_content, "html"))
+
+        # Connect and send
+        if settings.smtp_use_ssl:
+            server = smtplib.SMTP_SSL(settings.smtp_host, settings.smtp_port)
+        else:
+            server = smtplib.SMTP(settings.smtp_host, settings.smtp_port)
+            if settings.smtp_use_tls:
+                server.starttls()
+
+        server.login(settings.smtp_username, settings.smtp_password)
+        server.sendmail(settings.from_email, to_email, msg.as_string())
+        server.quit()
+
+    def _send_sendgrid_test(self, settings: StoreEmailSettings, to_email: str) -> None:
+        """Send test email via SendGrid."""
+        try:
+            from sendgrid import SendGridAPIClient
+            from sendgrid.helpers.mail import Mail
+        except ImportError:
+            raise ExternalServiceException(
+                service_name="SendGrid",
+                message="SendGrid library not installed. Contact support.",
+            )
+
+        message = Mail(
+            from_email=(settings.from_email, settings.from_name),
+            to_emails=to_email,
+            subject="Wizamart Email Configuration Test",
+            html_content="""
+            <html>
+            <body style="font-family: Arial, sans-serif; padding: 20px;">
+                <h2 style="color: #6b46c1;">Email Configuration Test</h2>
+                <p>This is a test email from <strong>Wizamart</strong>.</p>
+                <p style="color: #22c55e; font-weight: bold;">
+                    Your SendGrid settings are configured correctly!
+                </p>
+            </body>
+            </html>
+            """,
+        )
+
+        sg = SendGridAPIClient(settings.sendgrid_api_key)
+        response = sg.send(message)
+
+        if response.status_code >= 400:
+            raise ExternalServiceException(
+                service_name="SendGrid",
+                message=f"SendGrid error: HTTP {response.status_code}",
+            )
+
+    def _send_mailgun_test(self, settings: StoreEmailSettings, to_email: str) -> None:
+        """Send test email via Mailgun."""
+        import requests
+
+        response = requests.post(
+            f"https://api.mailgun.net/v3/{settings.mailgun_domain}/messages",
+            auth=("api", settings.mailgun_api_key),
+            data={
+                "from": f"{settings.from_name} <{settings.from_email}>",
+                "to": to_email,
+                "subject": "Wizamart Email Configuration Test",
+                "html": """
+                <html>
+                <body style="font-family: Arial, sans-serif; padding: 20px;">
+                    <h2 style="color: #6b46c1;">Email Configuration Test</h2>
+                    <p>This is a test email from <strong>Wizamart</strong>.</p>
+                    <p style="color: #22c55e; font-weight: bold;">
+                        Your Mailgun settings are configured correctly!
+                    </p>
+                </body>
+                </html>
+                """,
+            },
+            timeout=30,
+        )
+
+        if response.status_code >= 400:
+            raise ExternalServiceException(
+                service_name="Mailgun",
+                message=f"Mailgun error: {response.text}",
+            )
+
+    def _send_ses_test(self, settings: StoreEmailSettings, to_email: str) -> None:
+        """Send test email via Amazon SES."""
+        try:
+            import boto3
+        except ImportError:
+            raise ExternalServiceException(
+                service_name="Amazon SES",
+                message="boto3 library not installed. Contact support.",
+            )
+
+        client = boto3.client(
+            "ses",
+            region_name=settings.ses_region,
+            aws_access_key_id=settings.ses_access_key_id,
+            aws_secret_access_key=settings.ses_secret_access_key,
+        )
+
+        client.send_email(
+            Source=f"{settings.from_name} <{settings.from_email}>",
+            Destination={"ToAddresses": [to_email]},
+            Message={
+                "Subject": {"Data": "Wizamart Email Configuration Test"},
+                "Body": {
+                    "Html": {
+                        "Data": """
+                        <html>
+                        <body style="font-family: Arial, sans-serif; padding: 20px;">
+                            <h2 style="color: #6b46c1;">Email Configuration Test</h2>
+                            <p>This is a test email from <strong>Wizamart</strong>.</p>
+                            <p style="color: #22c55e; font-weight: bold;">
+                                Your Amazon SES settings are configured correctly!
+                            </p>
+                        </body>
+                        </html>
+                        """
+                    }
+                },
+            },
+        )
+
+    # =========================================================================
+    # TIER HELPERS
+    # =========================================================================
+
+    def get_available_providers(self, tier: TierCode | None) -> list[dict]:
+        """
+        Get list of available email providers for a tier.
+
+        Returns list of providers with availability status.
+        """
+        providers = [
+            {
+                "code": EmailProvider.SMTP.value,
+                "name": "SMTP",
+                "description": "Standard SMTP email server",
+                "available": True,
+                "tier_required": None,
+            },
+            {
+                "code": EmailProvider.SENDGRID.value,
+                "name": "SendGrid",
+                "description": "SendGrid email delivery platform",
+                "available": tier in PREMIUM_TIERS if tier else False,
+                "tier_required": "business",
+            },
+            {
+                "code": EmailProvider.MAILGUN.value,
+                "name": "Mailgun",
+                "description": "Mailgun email API",
+                "available": tier in PREMIUM_TIERS if tier else False,
+                "tier_required": "business",
+            },
+            {
+                "code": EmailProvider.SES.value,
+                "name": "Amazon SES",
+                "description": "Amazon Simple Email Service",
+                "available": tier in PREMIUM_TIERS if tier else False,
+                "tier_required": "business",
+            },
+        ]
+        return providers
+
+
+# Module-level service instance (singleton pattern)
+store_email_settings_service = StoreEmailSettingsService()

app/modules/messaging/tests/unit/test_email_template_service.py

@@ -0,0 +1,18 @@
+"""Unit tests for EmailTemplateService."""
+
+import pytest
+
+from app.modules.messaging.services.email_template_service import EmailTemplateService
+
+
+@pytest.mark.unit
+@pytest.mark.messaging
+class TestEmailTemplateService:
+    """Test suite for EmailTemplateService."""
+
+    def setup_method(self):
+        self.service = EmailTemplateService()
+
+    def test_service_instantiation(self):
+        """Service can be instantiated."""
+        assert self.service is not None

app/modules/messaging/tests/unit/test_store_email_settings_service.py

@@ -0,0 +1,367 @@
+# tests/unit/services/test_store_email_settings_service.py
+"""Unit tests for StoreEmailSettingsService."""
+
+from datetime import UTC, datetime
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from app.exceptions import (
+    AuthorizationException,
+    ResourceNotFoundException,
+    ValidationException,
+)
+from app.modules.billing.models import TierCode
+from app.modules.messaging.models import StoreEmailSettings
+from app.modules.messaging.services.store_email_settings_service import (
+    store_email_settings_service,
+)
+
+# =============================================================================
+# FIXTURES
+# =============================================================================
+
+
+@pytest.fixture
+def test_email_settings(db, test_store):
+    """Create test email settings for a store."""
+    settings = StoreEmailSettings(
+        store_id=test_store.id,
+        from_email="test@example.com",
+        from_name="Test Sender",
+        provider="smtp",
+        smtp_host="smtp.example.com",
+        smtp_port=587,
+        smtp_username="testuser",
+        smtp_password="testpass",
+        smtp_use_tls=True,
+        smtp_use_ssl=False,
+        is_configured=True,
+        is_verified=False,
+    )
+    db.add(settings)
+    db.commit()
+    db.refresh(settings)
+    return settings
+
+
+@pytest.fixture
+def test_verified_email_settings(db, test_store):
+    """Create verified email settings."""
+    settings = StoreEmailSettings(
+        store_id=test_store.id,
+        from_email="verified@example.com",
+        from_name="Verified Sender",
+        provider="smtp",
+        smtp_host="smtp.example.com",
+        smtp_port=587,
+        smtp_username="testuser",
+        smtp_password="testpass",
+        smtp_use_tls=True,
+        is_configured=True,
+        is_verified=True,
+        last_verified_at=datetime.now(UTC),
+    )
+    db.add(settings)
+    db.commit()
+    db.refresh(settings)
+    return settings
+
+
+# =============================================================================
+# READ OPERATION TESTS
+# =============================================================================
+
+
+@pytest.mark.unit
+@pytest.mark.email
+class TestStoreEmailSettingsRead:
+    """Test suite for reading email settings."""
+
+    def test_get_settings_exists(self, db, test_email_settings):
+        """Test getting settings when they exist."""
+        settings = store_email_settings_service.get_settings(db, test_email_settings.store_id)
+
+        assert settings is not None
+        assert settings.from_email == "test@example.com"
+        assert settings.provider == "smtp"
+
+    def test_get_settings_not_exists(self, db, test_store):
+        """Test getting settings when they don't exist."""
+        settings = store_email_settings_service.get_settings(db, test_store.id)
+
+        assert settings is None
+
+    def test_get_settings_or_404_exists(self, db, test_email_settings):
+        """Test get_settings_or_404 when settings exist."""
+        settings = store_email_settings_service.get_settings_or_404(db, test_email_settings.store_id)
+
+        assert settings is not None
+        assert settings.id == test_email_settings.id
+
+    def test_get_settings_or_404_not_exists(self, db, test_store):
+        """Test get_settings_or_404 raises exception when not found."""
+        with pytest.raises(ResourceNotFoundException) as exc:
+            store_email_settings_service.get_settings_or_404(db, test_store.id)
+
+        assert "store_email_settings" in str(exc.value)
+
+    def test_is_configured_true(self, db, test_email_settings):
+        """Test is_configured returns True for configured settings."""
+        result = store_email_settings_service.is_configured(db, test_email_settings.store_id)
+
+        assert result is True
+
+    def test_is_configured_false_not_exists(self, db, test_store):
+        """Test is_configured returns False when settings don't exist."""
+        result = store_email_settings_service.is_configured(db, test_store.id)
+
+        assert result is False
+
+    def test_get_status_configured(self, db, test_email_settings):
+        """Test get_status for configured settings."""
+        status = store_email_settings_service.get_status(db, test_email_settings.store_id)
+
+        assert status["is_configured"] is True
+        assert status["is_verified"] is False
+        assert status["provider"] == "smtp"
+        assert status["from_email"] == "test@example.com"
+
+    def test_get_status_not_configured(self, db, test_store):
+        """Test get_status when settings don't exist."""
+        status = store_email_settings_service.get_status(db, test_store.id)
+
+        assert status["is_configured"] is False
+        assert status["is_verified"] is False
+        assert status["provider"] is None
+
+
+# =============================================================================
+# WRITE OPERATION TESTS
+# =============================================================================
+
+
+@pytest.mark.unit
+@pytest.mark.email
+class TestStoreEmailSettingsWrite:
+    """Test suite for writing email settings."""
+
+    def test_create_settings(self, db, test_store):
+        """Test creating new email settings."""
+        data = {
+            "from_email": "new@example.com",
+            "from_name": "New Sender",
+            "provider": "smtp",
+            "smtp_host": "smtp.example.com",
+            "smtp_port": 587,
+            "smtp_username": "user",
+            "smtp_password": "pass",
+        }
+
+        settings = store_email_settings_service.create_or_update(
+            db=db,
+            store_id=test_store.id,
+            data=data,
+            current_tier=TierCode.ESSENTIAL,
+        )
+
+        assert settings.from_email == "new@example.com"
+        assert settings.provider == "smtp"
+        assert settings.smtp_host == "smtp.example.com"
+
+    def test_update_existing_settings(self, db, test_email_settings):
+        """Test updating existing settings."""
+        data = {
+            "from_email": "updated@example.com",
+            "from_name": "Updated Sender",
+        }
+
+        settings = store_email_settings_service.create_or_update(
+            db=db,
+            store_id=test_email_settings.store_id,
+            data=data,
+            current_tier=TierCode.ESSENTIAL,
+        )
+
+        assert settings.from_email == "updated@example.com"
+        assert settings.from_name == "Updated Sender"
+        # Other fields should remain unchanged
+        assert settings.smtp_host == "smtp.example.com"
+
+    def test_premium_provider_requires_business_tier(self, db, test_store):
+        """Test that premium providers require Business tier."""
+        data = {
+            "from_email": "test@example.com",
+            "from_name": "Test",
+            "provider": "sendgrid",
+            "sendgrid_api_key": "test-key",
+        }
+
+        with pytest.raises(AuthorizationException) as exc:
+            store_email_settings_service.create_or_update(
+                db=db,
+                store_id=test_store.id,
+                data=data,
+                current_tier=TierCode.ESSENTIAL,
+            )
+
+        assert "Business or Enterprise" in str(exc.value)
+
+    def test_premium_provider_allowed_for_business(self, db, test_store):
+        """Test that premium providers work with Business tier."""
+        data = {
+            "from_email": "test@example.com",
+            "from_name": "Test",
+            "provider": "sendgrid",
+            "sendgrid_api_key": "test-key",
+        }
+
+        settings = store_email_settings_service.create_or_update(
+            db=db,
+            store_id=test_store.id,
+            data=data,
+            current_tier=TierCode.BUSINESS,
+        )
+
+        assert settings.provider == "sendgrid"
+
+    def test_provider_change_resets_verification(self, db, test_verified_email_settings):
+        """Test that changing provider resets verification status."""
+        assert test_verified_email_settings.is_verified is True
+
+        data = {"smtp_host": "new-smtp.example.com"}
+
+        settings = store_email_settings_service.create_or_update(
+            db=db,
+            store_id=test_verified_email_settings.store_id,
+            data=data,
+            current_tier=TierCode.ESSENTIAL,
+        )
+
+        assert settings.is_verified is False
+
+    def test_delete_settings(self, db, test_email_settings):
+        """Test deleting email settings."""
+        store_id = test_email_settings.store_id
+
+        store_email_settings_service.delete(db, store_id)
+        db.commit()
+
+        # Verify deletion
+        settings = store_email_settings_service.get_settings(db, store_id)
+        assert settings is None
+
+    def test_delete_settings_not_found(self, db, test_store):
+        """Test deleting non-existent settings raises exception."""
+        with pytest.raises(ResourceNotFoundException):
+            store_email_settings_service.delete(db, test_store.id)
+
+
+# =============================================================================
+# VERIFICATION TESTS
+# =============================================================================
+
+
+@pytest.mark.unit
+@pytest.mark.email
+class TestStoreEmailSettingsVerification:
+    """Test suite for email verification."""
+
+    def test_verify_settings_not_configured(self, db, test_store):
+        """Test verification fails for non-existent settings."""
+        with pytest.raises(ResourceNotFoundException):
+            store_email_settings_service.verify_settings(db, test_store.id, "test@example.com")
+
+    def test_verify_settings_incomplete(self, db, test_store):
+        """Test verification fails for incomplete settings."""
+        # Create incomplete settings
+        settings = StoreEmailSettings(
+            store_id=test_store.id,
+            from_email="test@example.com",
+            from_name="Test",
+            provider="smtp",
+            # Missing SMTP config
+            is_configured=False,
+        )
+        db.add(settings)
+        db.commit()
+
+        with pytest.raises(ValidationException) as exc:
+            store_email_settings_service.verify_settings(db, test_store.id, "test@example.com")
+
+        assert "incomplete" in str(exc.value).lower()
+
+    @patch("smtplib.SMTP")
+    def test_verify_smtp_success(self, mock_smtp, db, test_email_settings):
+        """Test successful SMTP verification."""
+        # Mock SMTP connection
+        mock_server = MagicMock()
+        mock_smtp.return_value = mock_server
+
+        result = store_email_settings_service.verify_settings(
+            db,
+            test_email_settings.store_id,
+            "recipient@example.com",
+        )
+
+        assert result["success"] is True
+        assert "successfully" in result["message"].lower()
+
+    @patch("smtplib.SMTP")
+    def test_verify_smtp_failure(self, mock_smtp, db, test_email_settings):
+        """Test SMTP verification failure."""
+        # Mock SMTP error
+        mock_smtp.side_effect = Exception("Connection refused")
+
+        result = store_email_settings_service.verify_settings(
+            db,
+            test_email_settings.store_id,
+            "recipient@example.com",
+        )
+
+        assert result["success"] is False
+        assert "failed" in result["message"].lower()
+
+
+# =============================================================================
+# PROVIDER AVAILABILITY TESTS
+# =============================================================================
+
+
+@pytest.mark.unit
+@pytest.mark.email
+class TestStoreEmailProvidersAvailability:
+    """Test suite for provider availability checking."""
+
+    def test_get_providers_essential_tier(self, db):
+        """Test available providers for Essential tier."""
+        providers = store_email_settings_service.get_available_providers(TierCode.ESSENTIAL)
+
+        # Find SMTP provider
+        smtp = next((p for p in providers if p["code"] == "smtp"), None)
+        assert smtp is not None
+        assert smtp["available"] is True
+
+        # Find SendGrid provider
+        sendgrid = next((p for p in providers if p["code"] == "sendgrid"), None)
+        assert sendgrid is not None
+        assert sendgrid["available"] is False
+
+    def test_get_providers_business_tier(self, db):
+        """Test available providers for Business tier."""
+        providers = store_email_settings_service.get_available_providers(TierCode.BUSINESS)
+
+        # All providers should be available
+        for provider in providers:
+            assert provider["available"] is True
+
+    def test_get_providers_no_tier(self, db):
+        """Test available providers with no subscription."""
+        providers = store_email_settings_service.get_available_providers(None)
+
+        # Only SMTP should be available
+        smtp = next((p for p in providers if p["code"] == "smtp"), None)
+        assert smtp["available"] is True
+
+        sendgrid = next((p for p in providers if p["code"] == "sendgrid"), None)
+        assert sendgrid["available"] is False