31 |
|
43 |
| | 22 |
23 |
24 |
25 | {% block container %}
26 |
63 | |
64 | | 65 |
377 |
378 |
379 | Content
380 | """
381 | cleaned_html = backend._remove_comments(html_with_comments) # pylint: disable=W0212
382 |
383 | # Regular comments should be removed
384 | assert "HTML Comment" not in cleaned_html
385 | assert "Another Comment" not in cleaned_html
386 | assert "CSS Comment" not in cleaned_html
387 | assert "JavaScript Comment" not in cleaned_html
388 | assert "/* Multi-line" not in cleaned_html
389 | assert "Comment */" not in cleaned_html
390 | assert "End of line comment" not in cleaned_html
391 | assert "This is also a comment" not in cleaned_html
392 | assert "/*" not in cleaned_html
393 | assert "*/" not in cleaned_html
394 |
395 | # Content should remain
396 | assert "Content
" in cleaned_html
397 | assert ".class { color: red; }" in cleaned_html
398 | assert "var x = 1;" in cleaned_html
399 | assert "Link" in cleaned_html
400 | assert "//cdn.example.com" in cleaned_html
401 |
402 | # IE conditional comments should be preserved
403 | assert "" in cleaned_html
404 |
405 |
406 | def test_default_subject_and_preheader():
407 | """
408 | Test that the default subject and preheader are used when
409 | not provided in the template or context.
410 | """
411 | # Send an email without subject or preheader in template or context
412 | send_templated_mail(
413 | template_name="test_no_subject_preheader",
414 | from_email="from@example.com",
415 | recipient_list=["to@example.com"],
416 | context={"name": "Test User"},
417 | )
418 |
419 | assert len(mail.outbox) == 1
420 | email = mail.outbox[0]
421 |
422 | # Default subject should be 'Hello!' as per the default in the backend
423 | assert email.subject == _("Hello!")
424 | # Preheader should be empty string by default
425 | # Since preheader may not be directly visible, check in the HTML content
426 | html_content = email.alternatives[0][0]
427 | assert "Hello!" in email.subject
428 | assert '" in html_content
431 |
432 |
433 | def test_subject_and_preheader_provided():
434 | """
435 | Test that when subject and preheader are provided in the template,
436 | they override the default values.
437 | """
438 | # Send an email with subject and preheader in the template
439 | send_templated_mail(
440 | template_name="test_subject_preheader_provided",
441 | from_email="from@example.com",
442 | recipient_list=["to@example.com"],
443 | context={"name": "Test User"},
444 | )
445 |
446 | assert len(mail.outbox) == 1
447 | email = mail.outbox[0]
448 |
449 | # Subject and preheader should be as provided in the template
450 | assert email.subject == "Subject from Template"
451 | html_content = email.alternatives[0][0]
452 | assert 'Preheader from Template" in html_content
454 |
455 |
456 | def test_rendering_local_links():
457 | """Test that local links are rendered correctly by premailer if base_url is provided."""
458 | import random # pylint: disable=C0415
459 |
460 | from django.urls import reverse
461 |
462 | some_id = random.randint(1, 100)
463 | send_templated_mail(
464 | template_name="test_render_local_links",
465 | from_email="from@example.com",
466 | recipient_list=["to@example.com"],
467 | base_url="http://exampleeee.com",
468 | context={
469 | "name": "Test User",
470 | "some_id": some_id,
471 | "url": reverse("index", args=[some_id]),
472 | },
473 | )
474 |
475 | assert len(mail.outbox) == 1
476 | email = mail.outbox[0]
477 | html_content = email.alternatives[0][0]
478 |
479 | url = reverse("index", args=[some_id])
480 |
481 | # Check that the email was sent
482 | assert email.subject == "Hello!"
483 | assert "Hello Test User!" in email.body
484 | assert "Hello Test User!" in html_content
485 |
486 | # Check that the link was rendered correctly twice
487 | assert html_content.count(f'index") == 2
489 |
490 |
491 | def test_custom_default_subject_and_preheader():
492 | """
493 | Test that the custom default subject and preheader from settings
494 | are used when not provided in the template or context.
495 | """
496 | settings.TEMPLATED_EMAIL_DEFAULT_SUBJECT = "Default Subject from Settings"
497 | settings.TEMPLATED_EMAIL_DEFAULT_PREHEADER = "Default Preheader from Settings"
498 | # Send an email without subject or preheader in template or context
499 | send_templated_mail(
500 | template_name="test_no_subject_preheader",
501 | from_email="from@example.com",
502 | recipient_list=["to@example.com"],
503 | context={"name": "Test User"},
504 | )
505 |
506 | assert len(mail.outbox) == 1
507 | email = mail.outbox[0]
508 |
509 | # Subject should be the custom default from settings
510 | assert email.subject == "Default Subject from Settings"
511 | # Preheader should be the custom default from settings
512 | html_content = email.alternatives[0][0]
513 | assert 'Default Preheader from Settings" in html_content
515 |
516 |
517 | def test_custom_html2text_settings(backend) -> None:
518 | """Test that custom html2text settings are properly applied."""
519 | # Set custom html2text settings
520 | backend.html2text_settings = {"ignore_links": True, "ignore_images": True, "body_width": 0}
521 |
522 | html_content = """
523 |
524 | 
526 |
527 | """
528 |
529 | plain_text = backend._generate_plain_text(html_content)
530 |
531 | # Links and images should be ignored based on our settings
532 | assert "http://example.com" not in plain_text
533 | assert "test image" not in plain_text
534 |
535 |
536 | def test_template_blocks_extraction(backend) -> None:
537 | """Test extraction of subject and content blocks from template."""
538 | template_content = """
539 | {% block subject %}Test Subject{% endblock %}
540 |
541 | {% block content %}
542 | # Test Content
543 |
544 | This is test content.
545 | {% endblock %}
546 | """
547 |
548 | context = {}
549 | blocks = backend._extract_blocks(template_content, context)
550 |
551 | assert blocks["subject"] == "Test Subject"
552 | assert "# Test Content" in blocks["content"]
553 | assert "This is test content." in blocks["content"]
554 |
555 |
556 | def test_default_subject_preheader_settings(backend) -> None:
557 | """Test that default subject and preheader settings are used when not provided."""
558 | from django.test import override_settings
559 |
560 | custom_subject = "Custom Default Subject"
561 | custom_preheader = "Custom Default Preheader"
562 |
563 | with override_settings(
564 | TEMPLATED_EMAIL_DEFAULT_SUBJECT=custom_subject, TEMPLATED_EMAIL_DEFAULT_PREHEADER=custom_preheader
565 | ):
566 | # Create a new backend instance to pick up the settings
567 | new_backend = MarkdownTemplateBackend()
568 | assert new_backend.default_subject == custom_subject
569 | assert new_backend.default_preheader == custom_preheader
570 |
571 |
572 | def test_fail_silently_render_email(backend) -> None:
573 | """Test that _render_email handles errors gracefully with fail_silently=True."""
574 | # Set fail_silently on the backend
575 | backend.fail_silently = True
576 |
577 | # Test with non-existent template
578 | result = backend._render_email(
579 | template_name="non_existent_template",
580 | context={},
581 | )
582 |
583 | # Should return fallback content
584 | assert result["html"] == "Email template rendering failed."
585 | assert result["plain"] == "Email template rendering failed."
586 | assert result["subject"] == backend.default_subject
587 | assert result["preheader"] == backend.default_preheader
588 |
589 | def test_fail_silently_none_initialization() -> None:
590 | """Test that backend handles fail_silently=None during initialization."""
591 | from django.test import override_settings
592 |
593 | # When fail_silently is explicitly None, it should fall back to settings
594 | backend_with_none = MarkdownTemplateBackend(fail_silently=None)
595 |
596 | # Should use the default from settings (False in test settings)
597 | assert backend_with_none.fail_silently is False
598 |
599 | # Test with a setting override
600 | with override_settings(TEMPLATED_EMAIL_FAIL_SILENTLY=True):
601 | backend_with_setting = MarkdownTemplateBackend(fail_silently=None)
602 | assert backend_with_setting.fail_silently is True
603 |
604 |
605 | def test_template_without_content_block(backend) -> None:
606 | """Test rendering a template without explicit {% block content %}."""
607 | result = backend._render_email(
608 | template_name="test_no_content_block",
609 | context={},
610 | )
611 |
612 | # Should extract content using fallback regex method
613 | assert "Simple Markdown" in result["html"]
614 | assert "Bold text" in result["html"]
615 | assert "italic text" in result["html"]
616 | # CSS inlining adds styles, so just check for content
617 | assert "List item 1" in result["html"]
618 | assert "List item 2" in result["html"]
619 |
620 | # Subject and preheader should still be extracted
621 | assert result["subject"] == "Test Email Without Content Block"
622 | assert result["preheader"] == "Test preheader"
623 |
624 | # Plain text should also work
625 | assert "Simple Markdown" in result["plain"]
626 | assert "Bold text" in result["plain"]
627 |
628 |
629 | def test_markdown_render_error_with_fail_silently() -> None:
630 | """Test that MarkdownRenderError is caught when fail_silently=True."""
631 | from unittest.mock import patch
632 | from templated_email_md.exceptions import MarkdownRenderError
633 |
634 | backend = MarkdownTemplateBackend(fail_silently=True)
635 |
636 | # Mock markdown.markdown to raise an exception
637 | with patch('templated_email_md.backend.markdown.markdown') as mock_markdown:
638 | mock_markdown.side_effect = ValueError("Invalid markdown extension")
639 |
640 | # Should return the raw content instead of raising
641 | result = backend._render_markdown("# Test content")
642 | assert result == "# Test content"
643 |
644 |
645 | def test_markdown_render_error_without_fail_silently() -> None:
646 | """Test that MarkdownRenderError is raised when fail_silently=False."""
647 | from unittest.mock import patch
648 | from templated_email_md.exceptions import MarkdownRenderError
649 |
650 | backend = MarkdownTemplateBackend(fail_silently=False)
651 |
652 | # Mock markdown.markdown to raise an exception
653 | with patch('templated_email_md.backend.markdown.markdown') as mock_markdown:
654 | mock_markdown.side_effect = ValueError("Invalid markdown extension")
655 |
656 | # Should raise MarkdownRenderError
657 | with pytest.raises(MarkdownRenderError) as exc_info:
658 | backend._render_markdown("# Test content")
659 |
660 | assert "Invalid markdown extension" in str(exc_info.value)
661 |
662 |
663 | def test_css_inlining_error_with_fail_silently() -> None:
664 | """Test that CSSInliningError is caught when fail_silently=True."""
665 | from unittest.mock import patch
666 | from templated_email_md.exceptions import CSSInliningError
667 |
668 | backend = MarkdownTemplateBackend(fail_silently=True)
669 |
670 | # Mock premailer.transform to raise an exception
671 | with patch('templated_email_md.backend.premailer.transform') as mock_premailer:
672 | mock_premailer.side_effect = OSError("Network error fetching CSS")
673 |
674 | # Should return the original HTML instead of raising
675 | test_html = "Test content with a link
525 |
526 | Test content
" 676 | result = backend._inline_css(test_html, base_url="http://example.com") 677 | assert result == test_html 678 | 679 | 680 | def test_css_inlining_error_without_fail_silently() -> None: 681 | """Test that CSSInliningError is raised when fail_silently=False.""" 682 | from unittest.mock import patch 683 | from templated_email_md.exceptions import CSSInliningError 684 | 685 | backend = MarkdownTemplateBackend(fail_silently=False) 686 | 687 | # Mock premailer.transform to raise an exception 688 | with patch('templated_email_md.backend.premailer.transform') as mock_premailer: 689 | mock_premailer.side_effect = OSError("Network error fetching CSS") 690 | 691 | # Should raise CSSInliningError 692 | with pytest.raises(CSSInliningError) as exc_info: 693 | backend._inline_css("Test content
", base_url="http://example.com") 694 | 695 | assert "Network error fetching CSS" in str(exc_info.value) 696 | 697 | 698 | def test_plain_text_generation_error_with_fail_silently() -> None: 699 | """Test that plain text generation errors are caught when fail_silently=True.""" 700 | from unittest.mock import patch 701 | 702 | backend = MarkdownTemplateBackend(fail_silently=True) 703 | 704 | # Mock html2text to raise an exception 705 | with patch('templated_email_md.backend.html2text.HTML2Text') as mock_html2text: 706 | mock_instance = mock_html2text.return_value 707 | mock_instance.handle.side_effect = AttributeError("Invalid HTML structure") 708 | 709 | # Should return fallback content instead of raising 710 | result = backend._get_plain_text_content_from_template("Test
") 711 | assert result == "Email template rendering failed." 712 | 713 | 714 | def test_plain_text_generation_error_without_fail_silently() -> None: 715 | """Test that plain text generation errors are raised when fail_silently=False.""" 716 | from unittest.mock import patch 717 | 718 | backend = MarkdownTemplateBackend(fail_silently=False) 719 | 720 | # Mock html2text to raise an exception 721 | with patch('templated_email_md.backend.html2text.HTML2Text') as mock_html2text: 722 | mock_instance = mock_html2text.return_value 723 | mock_instance.handle.side_effect = AttributeError("Invalid HTML structure") 724 | 725 | # Should raise AttributeError 726 | with pytest.raises(AttributeError) as exc_info: 727 | backend._get_plain_text_content_from_template("Test
") 728 | 729 | assert "Invalid HTML structure" in str(exc_info.value) 730 | 731 | 732 | def test_context_base_url_restoration(backend) -> None: 733 | """Test that _base_url in context is properly restored after send().""" 734 | from django.core import mail 735 | 736 | # Create context with a pre-existing _base_url 737 | context = { 738 | "name": "Test User", 739 | "_base_url": "http://original-url.com", 740 | } 741 | 742 | # Send email with a different base_url 743 | backend.send( 744 | template_name="test_message", 745 | from_email="from@example.com", 746 | recipient_list=["to@example.com"], 747 | context=context, 748 | base_url="http://new-url.com", 749 | ) 750 | 751 | # Context should be restored to original value 752 | assert context["_base_url"] == "http://original-url.com" 753 | 754 | 755 | def test_markdown_import_error() -> None: 756 | """Test handling of ImportError when markdown extension is not found.""" 757 | from unittest.mock import patch 758 | from templated_email_md.exceptions import MarkdownRenderError 759 | 760 | backend = MarkdownTemplateBackend(fail_silently=False) 761 | 762 | # Mock markdown.markdown to raise ImportError 763 | with patch('templated_email_md.backend.markdown.markdown') as mock_markdown: 764 | mock_markdown.side_effect = ImportError("Extension 'invalid.extension' not found") 765 | 766 | # Should raise MarkdownRenderError 767 | with pytest.raises(MarkdownRenderError) as exc_info: 768 | backend._render_markdown("# Test content") 769 | 770 | assert "Extension 'invalid.extension' not found" in str(exc_info.value) 771 | --------------------------------------------------------------------------------