Add Html Mail Parser able to detect Quote and Signature elements and order

tracim/tracim/lib/email_body_parser.py

@@ -0,0 +1,347 @@
+import typing
+
+from bs4 import BeautifulSoup
+from bs4 import Tag
+from bs4 import NavigableString
+
+
+class BodyMailPartType(object):
+    Signature = 'sign'
+    Main = 'main'
+    Quote = 'quote'
+
+
+class BodyMailPart(object):
+    def __init__(
+            self,
+            text: str,
+            part_type: str
+    )-> None:
+        self.text = text
+        self.part_type = part_type
+
+
+class BodyMailParts(object):
+    """
+    Data Structure to Distinct part of a Mail body into a "list" of BodyMailPart
+    When 2 similar BodyMailPart (same part_type) are added one after the other,
+    it doesn't create a new Part, it just merge those elements into one.
+    It should always have only one Signature type part, at the end of the body.
+    This object doesn't provide other set method than append() in order to
+    preserve object coherence.
+    """
+    def __init__(self) -> None:
+        self._list = []  # type; List[BodyMailPart]
+
+    def __len__(self) -> int:
+        return len(self._list)
+
+    def __getitem__(self, index) -> BodyMailPart:
+        return self._list[index]
+
+    def __delitem__(self, index) -> None:
+        del self._list[index]
+        # Todo : check consistance
+
+    def append(self, value) -> None:
+        BodyMailParts._check_value(value)
+        self._check_sign_last_elem(value)
+        self._append(value)
+
+    def _append(self, value):
+        if len(self._list) > 0 and self._list[-1].part_type == value.part_type:
+            self._list[-1].text += value.text
+        else:
+            self._list.append(value)
+
+    @classmethod
+    def _check_value(cls, value) -> None:
+        if not isinstance(value, BodyMailPart):
+            raise TypeError()
+
+    def _check_sign_last_elem(self, value: BodyMailPart) -> None:
+        """
+        Check if last elem is a signature, if true, refuse to add a
+        non-signature item.
+        :param value: BodyMailPart to check
+        :return: None
+        """
+        if len(self._list) > 0:
+            if self._list[-1].part_type == BodyMailPartType.Signature and \
+                            value.part_type != BodyMailPartType.Signature:
+                raise SignatureIndexError(
+                    "Can't add element after signature element.")
+
+    def disable_signature(self) -> None:
+        """
+        Consider the chosen signature to a normal main content element
+        :return: None
+        """
+        if (
+            len(self._list) > 0 and
+            self._list[-1].part_type == BodyMailPartType.Signature
+        ):
+            self._list[-1].part_type = BodyMailPartType.Main
+            # If possible, concatenate with previous elem
+            if (
+                len(self._list) > 1 and
+                self._list[-2].part_type == BodyMailPartType.Main
+            ):
+                self._list[-2].text += self._list[-1].text
+                del self._list[-1]
+
+    def drop_part_type(self, part_type: str) -> None:
+        """
+        Drop all elem of one part_type
+        :param part_type: part_type to completely remove
+        :return: None
+        """
+        new_list = [x for x in self._list if x.part_type != part_type]
+        self._list = []
+        # INFO - G.M - 2017-11-27 - use append() to have a consistent list
+        for elem in new_list:
+            self.append(elem)
+
+    def get_nb_part_type(self, part_type: str) -> int:
+        """
+        Get number of elements of one part_type
+        :param part_type: part_type to check
+        :return: number of part_type elements
+        """
+        count = 0
+        for elem in self._list:
+            if elem.part_type == part_type:
+                count += 1
+        return count
+
+    def __str__(self) -> str:
+        s_mail = ''
+        for elem in self._list:
+            s_mail += elem.text
+        return str(s_mail)
+
+
+class SignatureIndexError(Exception):
+    pass
+
+
+class HtmlChecker(object):
+
+    @classmethod
+    def _has_attr_value(
+            cls,
+            elem: typing.Union[Tag, NavigableString],
+            attribute_name: str,
+            attribute_value: str,
+    )-> bool:
+        if isinstance(elem, Tag) and \
+                        attribute_name in elem.attrs and \
+                        attribute_value in elem.attrs[attribute_name]:
+            return True
+        return False
+
+
+class HtmlMailQuoteChecker(HtmlChecker):
+
+    @classmethod
+    def is_quote(
+            cls,
+            elem: typing.Union[Tag, NavigableString]
+    ) -> bool:
+        return cls._is_standard_quote(elem) \
+               or cls._is_thunderbird_quote(elem) \
+               or cls._is_gmail_quote(elem) \
+               or cls._is_yahoo_quote(elem) \
+               or cls._is_roundcube_quote(elem)
+
+    @classmethod
+    def _is_standard_quote(
+            cls,
+            elem: typing.Union[Tag, NavigableString]
+    ) -> bool:
+        if isinstance(elem, Tag) \
+                and elem.name.lower() == 'blockquote':
+            return True
+        return False
+
+    @classmethod
+    def _is_thunderbird_quote(
+            cls,
+            elem: typing.Union[Tag, NavigableString]
+    ) -> bool:
+        return cls._has_attr_value(elem, 'class', 'moz-cite-prefix')
+
+    @classmethod
+    def _is_gmail_quote(
+            cls,
+            elem: typing.Union[Tag, NavigableString]
+    ) -> bool:
+        if cls._has_attr_value(elem, 'class', 'gmail_extra'):
+            for child in elem.children:
+                if cls._has_attr_value(child, 'class', 'gmail_quote'):
+                    return True
+        return False
+
+    @classmethod
+    def _is_yahoo_quote(
+            cls,
+            elem: typing.Union[Tag, NavigableString]
+    ) -> bool:
+        return cls._has_attr_value(elem, 'class', 'yahoo_quoted')
+
+    @classmethod
+    def _is_roundcube_quote(
+            cls,
+            elem: typing.Union[Tag, NavigableString]
+    ) -> bool:
+        return cls._has_attr_value(elem, 'id', 'reply-intro')
+
+
+class HtmlMailSignatureChecker(HtmlChecker):
+
+    @classmethod
+    def is_signature(
+            cls,
+            elem: typing.Union[Tag, NavigableString]
+    ) -> bool:
+        return cls._is_thunderbird_signature(elem) \
+               or cls._is_gmail_signature(elem)
+
+    @classmethod
+    def _is_thunderbird_signature(
+            cls,
+            elem: typing.Union[Tag, NavigableString]
+    ) -> bool:
+        return cls._has_attr_value(elem,
+                                   'class',
+                                   'moz-signature')
+
+    @classmethod
+    def _is_gmail_signature(
+            cls,
+            elem: typing.Union[Tag, NavigableString]
+    ) -> bool:
+        if cls._has_attr_value(elem, 'class', 'gmail_signature'):
+            return True
+        if cls._has_attr_value(elem, 'class', 'gmail_extra'):
+            for child in elem.children:
+                if cls._has_attr_value(child, 'class', 'gmail_signature'):
+                    return True
+        if isinstance(elem,Tag) and elem.name.lower() == 'div':
+            for child in elem.children:
+                if cls._has_attr_value(child, 'class', 'gmail_signature'):
+                    return True
+        return False
+
+
+class ParsedHTMLMail(object):
+    """
+    Parse HTML Mail depending of some rules.
+    Distinct part of html mail body using BodyMailParts object and
+    process different rules.
+    """
+
+    def __init__(self, html_body: str):
+        self.src_html_body = html_body
+
+    def __str__(self):
+        return str(self._parse_mail())
+
+    def get_elements(self):
+        tree = self._make_sanitized_tree()
+        return self._distinct_elements(tree)
+
+    def _parse_mail(self) -> BodyMailParts:
+        elements = self.get_elements()
+        elements = self._process_elements(elements)
+        return elements
+
+    def _make_sanitized_tree(self):
+        """
+        Get only html body content and remove some unneeded elements
+        :return:
+        """
+        tree = BeautifulSoup(self.src_html_body, 'html.parser')
+
+        # Only parse body part of html if available
+        subtree = tree.find('body')
+        if subtree:
+            tree = BeautifulSoup(str(subtree), 'html.parser')
+
+        # if some sort of "meta_div", unwrap it
+        while len(tree.findAll(recursive=None)) == 1 and \
+                tree.find().name.lower() in ['body', 'div']:
+            tree.find().unwrap()
+
+        # drop some not useful html elem
+        for tag in tree.findAll():
+            if tag.name.lower() in ['br']:
+                tag.unwrap()
+                continue
+            if tag.name.lower() in ['script', 'style']:
+                tag.extract()
+
+        return tree
+
+    @classmethod
+    def _distinct_elements(cls, tree: BeautifulSoup) -> BodyMailParts:
+        elements = BodyMailParts()
+        for tag in list(tree):
+            txt = str(tag)
+            part_type = BodyMailPartType.Main
+            if isinstance(tag, NavigableString):
+                txt = tag.replace('\n', '').strip()
+            if not txt:
+                continue
+            if HtmlMailQuoteChecker.is_quote(tag):
+                part_type = BodyMailPartType.Quote
+            elif HtmlMailSignatureChecker.is_signature(tag):
+                part_type = BodyMailPartType.Signature
+            element = BodyMailPart(txt, part_type)
+            try:
+                elements.append(element)
+            except SignatureIndexError:
+                elements.disable_signature()
+                elements.append(element)
+        return elements
+
+    @classmethod
+    def _process_elements(cls, elements: BodyMailParts) -> BodyMailParts:
+        if len(elements) >= 2:
+            # Case 1 and 2, only one main and one quote
+            if elements.get_nb_part_type('main') == 1 and \
+                            elements.get_nb_part_type('quote') == 1:
+                # Case 1 : Main first
+                if elements[0].part_type == BodyMailPartType.Main:
+                    cls._process_main_first_case(elements)
+                # Case 2 : Quote first
+                if elements[0].part_type == BodyMailPartType.Quote:
+                    cls._process_quote_first_case(elements)
+            else:
+                # Case 3 : Multiple quotes and/or main
+                cls._process_multiples_elems_case(elements)
+        else:
+            cls._process_default_case(elements)
+            # default case (only one element or empty list)
+        return elements
+
+    @classmethod
+    def _process_quote_first_case(cls, elements: BodyMailParts):
+        elements.drop_part_type(BodyMailPartType.Signature)
+        pass
+
+    @classmethod
+    def _process_main_first_case(cls, elements: BodyMailParts):
+        elements.drop_part_type(BodyMailPartType.Quote)
+        elements.drop_part_type(BodyMailPartType.Signature)
+        pass
+
+    @classmethod
+    def _process_multiples_elems_case(cls, elements: BodyMailParts):
+        elements.drop_part_type(BodyMailPartType.Signature)
+        pass
+
+    @classmethod
+    def _process_default_case(cls, elements: BodyMailParts):
+        elements.drop_part_type(BodyMailPartType.Quote)
+        elements.drop_part_type(BodyMailPartType.Signature)

tracim/tracim/lib/email_fetcher.py

@@ -17,16 +17,16 @@ from bs4 import BeautifulSoup, Tag
 from email_reply_parser import EmailReplyParser
 
 from tracim.lib.base import logger
+from tracim.lib.email_body_parser import ParsedHTMLMail
 
 TRACIM_SPECIAL_KEY_HEADER = 'X-Tracim-Key'
 # TODO BS 20171124: Think about replace thin dict config by object
-BEAUTIFULSOUP_HTML_BODY_PARSE_CONFIG = {
-    'tag_blacklist': ['script', 'style', 'blockquote'],
-    'class_blacklist': ['moz-cite-prefix', 'gmail_extra', 'gmail_quote',
-                        'yahoo_quoted'],
+BEAUTIFULSOUP_HTML_BODY_SANITIZE_CONFIG = {
+    'tag_blacklist': ['script', 'style'],
+    'class_blacklist': [],
     'id_blacklist': ['reply-intro'],
     'tag_whitelist': ['a', 'b', 'strong', 'i', 'br', 'ul', 'li', 'ol',
-                      'em', 'i', 'u',
+                      'em', 'i', 'u', 'blockquote', 'h1','h2','h3','h4',
                       'thead', 'tr', 'td', 'tbody', 'table', 'p', 'pre'],
     'attrs_whitelist': ['href'],
 }
@@ -74,7 +74,8 @@ class DecodedMail(object):
             elif content_type == CONTENT_TYPE_TEXT_HTML:
                 html_body = body_part.get_payload(decode=True).decode(
                     charset)
-                body = DecodedMail._parse_html_body(html_body)
+                html_body = str(ParsedHTMLMail(html_body))
+                body = DecodedMail._sanitize_html_body(html_body)
 
         return body
 
@@ -82,13 +83,13 @@ class DecodedMail(object):
     def _parse_txt_body(cls, txt_body: str) -> str:
         txt_body = EmailReplyParser.parse_reply(txt_body)
         html_body = markdown.markdown(txt_body)
-        body = DecodedMail._parse_html_body(html_body)
+        body = DecodedMail._sanitize_html_body(html_body)
         return body
 
     @classmethod
-    def _parse_html_body(cls, html_body: str) -> str:
+    def _sanitize_html_body(cls, html_body: str) -> str:
         soup = BeautifulSoup(html_body, 'html.parser')
-        config = BEAUTIFULSOUP_HTML_BODY_PARSE_CONFIG
+        config = BEAUTIFULSOUP_HTML_BODY_SANITIZE_CONFIG
         for tag in soup.findAll():
             if DecodedMail._tag_to_extract(tag):
                 tag.extract()
@@ -103,7 +104,7 @@ class DecodedMail(object):
 
     @classmethod
     def _tag_to_extract(cls, tag: Tag) -> bool:
-        config = BEAUTIFULSOUP_HTML_BODY_PARSE_CONFIG
+        config = BEAUTIFULSOUP_HTML_BODY_SANITIZE_CONFIG
         if tag.name.lower() in config['tag_blacklist']:
             return True
         if 'class' in tag.attrs:

tracim/tracim/tests/library/test_email_body_parser.py

@@ -0,0 +1,582 @@
+from tracim.lib.email_body_parser import HtmlMailQuoteChecker
+from tracim.lib.email_body_parser import HtmlMailSignatureChecker
+from tracim.lib.email_body_parser import BodyMailParts
+from tracim.lib.email_body_parser import BodyMailPart
+from tracim.lib.email_body_parser import BodyMailPartType
+from tracim.lib.email_body_parser import SignatureIndexError
+from tracim.lib.email_body_parser import ParsedHTMLMail
+from tracim.tests import TestStandard
+from bs4 import BeautifulSoup,Tag
+from nose.tools import raises
+
+
+class TestHtmlMailQuoteChecker(TestStandard):
+    def test_unit__is_standard_quote_ok(self):
+        soup = BeautifulSoup('<blockquote></blockquote>', 'html.parser')
+        main_elem = soup.find()
+        assert HtmlMailQuoteChecker._is_standard_quote(main_elem) is True
+
+    def test_unit__is_standard_quote_no(self):
+        soup = BeautifulSoup('<a></a>')
+        main_elem = soup.find()
+        assert HtmlMailQuoteChecker._is_standard_quote(main_elem) is False
+
+    def test_unit__is_thunderbird_quote_ok(self):
+        soup = BeautifulSoup('<div class="moz-cite-prefix"></div>',
+                             'html.parser')
+        main_elem = soup.find()
+        assert HtmlMailQuoteChecker._is_thunderbird_quote(main_elem) is True
+
+    def test_unit__is_thunderbird_quote_no(self):
+        soup = BeautifulSoup('<div class="nothing"></div>')
+        main_elem = soup.find()
+        assert HtmlMailQuoteChecker._is_thunderbird_quote(main_elem) is False
+
+    def test_unit__is_gmail_quote_ok(self):
+        html = '<div class="gmail_extra">' + \
+              '<a></a><div class="gmail_quote"></div>' + \
+              '</div>'
+        soup = BeautifulSoup(html, 'html.parser')
+        main_elem = soup.find()
+        assert HtmlMailQuoteChecker._is_gmail_quote(main_elem) is True
+
+    def test_unit__is_gmail_quote_no(self):
+        soup = BeautifulSoup('<div class="nothing"></div>', 'html.parser')
+        main_elem = soup.find()
+        assert HtmlMailQuoteChecker._is_gmail_quote(main_elem) is False
+
+    def test_unit__is_gmail_quote_no_2(self):
+        html = '<div class="gmail_extra">' + \
+              '<a></a><div class="gmail_signature"></div>' + \
+              '</div>'
+        soup = BeautifulSoup(html, 'html.parser')
+        main_elem = soup.find()
+        assert HtmlMailQuoteChecker._is_gmail_quote(main_elem) is False
+
+    # TODO - G.M - 2017-11-24 - Check Yahoo and New roundcube html mail with
+    # correct mail example
+
+
+class TestHtmlMailSignatureChecker(TestStandard):
+    def test_unit__is_thunderbird_signature_ok(self):
+        soup = BeautifulSoup('<div class="moz-signature"></div>', 'html.parser')
+        main_elem = soup.find()
+        assert HtmlMailSignatureChecker._is_thunderbird_signature(main_elem) is True  # nopep8
+
+    def test_unit__is_thunderbird_signature_no(self):
+        soup = BeautifulSoup('<div class="other"></div>', 'html.parser')
+        main_elem = soup.find()
+        assert HtmlMailSignatureChecker._is_thunderbird_signature(main_elem) is False  # nopep8
+
+    def test_unit__is_gmail_signature_ok(self):
+        html = '<div class="gmail_extra">' + \
+               '<a></a><div class="gmail_quote"></div>' + \
+               '</div>'
+        soup = BeautifulSoup(html, 'html.parser')
+        main_elem = soup.find()
+        assert HtmlMailSignatureChecker._is_gmail_signature(main_elem) is False
+
+    def test_unit__is_gmail_signature_no(self):
+        soup = BeautifulSoup('<div class="nothing"></div>', 'html.parser')
+        main_elem = soup.find()
+        assert HtmlMailSignatureChecker._is_gmail_signature(main_elem) is False
+
+    def test_unit__is_gmail_signature_yes(self):
+        html = '<div class="gmail_extra">' + \
+               '<a></a><div class="gmail_signature"></div>' + \
+               '</div>'
+        soup = BeautifulSoup(html, 'html.parser')
+        main_elem = soup.find()
+        assert HtmlMailSignatureChecker._is_gmail_signature(main_elem) is True
+
+    def test_unit__is_gmail_signature_yes_2(self):
+        html = '<div class="gmail_signature">' + \
+               '</div>'
+        soup = BeautifulSoup(html, 'html.parser')
+        main_elem = soup.find()
+        assert HtmlMailSignatureChecker._is_gmail_signature(main_elem) is True
+
+class TestBodyMailsParts(TestStandard):
+
+    def test_unit__std_list_methods(self):
+        mail_parts = BodyMailParts()
+        assert len(mail_parts) == 0
+        a = BodyMailPart('a', BodyMailPartType.Main)
+        mail_parts._list.append(a)
+        assert len(mail_parts) == 1
+        assert mail_parts[0] == a
+        del mail_parts[0]
+        assert len(mail_parts) == 0
+
+    def test_unit__append_same_type(self):
+        mail_parts = BodyMailParts()
+        a = BodyMailPart('a', BodyMailPartType.Main)
+        mail_parts._append(a)
+        b = BodyMailPart('b', BodyMailPartType.Main)
+        mail_parts._append(b)
+        assert len(mail_parts) == 1
+        assert mail_parts[0].part_type == BodyMailPartType.Main
+        assert mail_parts[0].text == 'ab'
+
+    def test_unit__append_different_type(self):
+        mail_parts = BodyMailParts()
+        a = BodyMailPart('a', BodyMailPartType.Main)
+        mail_parts.append(a)
+        b = BodyMailPart('b', BodyMailPartType.Quote)
+        mail_parts._append(b)
+        assert len(mail_parts) == 2
+        assert mail_parts[0] == a
+        assert mail_parts[1] == b
+
+    @raises(TypeError)
+    def test_unit__check_value__type_error(self):
+        mail_parts = BodyMailParts()
+        mail_parts._check_value('a')
+
+    def test_unit__check_value__ok(self):
+        mail_parts = BodyMailParts()
+        a = BodyMailPart('a', BodyMailPartType.Main)
+        mail_parts._check_value(a)
+
+    @raises(SignatureIndexError)
+    def test_unit__check_sign_last_elem_check_main_after_sign(self):
+        mail_parts = BodyMailParts()
+        a = BodyMailPart('a', BodyMailPartType.Main)
+        mail_parts._list.append(a)
+        b = BodyMailPart('b', BodyMailPartType.Signature)
+        mail_parts._list.append(b)
+        c = BodyMailPart('c', BodyMailPartType.Main)
+        mail_parts._check_sign_last_elem(c)
+
+    def test_unit__check_sign_last_elem_check_sign_after_sign(self):
+        mail_parts = BodyMailParts()
+        a = BodyMailPart('a', BodyMailPartType.Main)
+        mail_parts._list.append(a)
+        b = BodyMailPart('b', BodyMailPartType.Signature)
+        mail_parts._list.append(b)
+        c = BodyMailPart('c', BodyMailPartType.Signature)
+        mail_parts._check_sign_last_elem(c)
+
+    def test_unit__disable_signature_no_sign(self):
+        mail_parts = BodyMailParts()
+        a = BodyMailPart('a', BodyMailPartType.Main)
+        mail_parts._list.append(a)
+        b = BodyMailPart('b', BodyMailPartType.Quote)
+        mail_parts._list.append(b)
+        mail_parts.disable_signature()
+        assert mail_parts[1] == b
+
+    def test_unit__disable_signature_sign_quote_as_previous_elem(self):
+        mail_parts = BodyMailParts()
+        a = BodyMailPart('a', BodyMailPartType.Main)
+        mail_parts._list.append(a)
+        b = BodyMailPart('b', BodyMailPartType.Quote)
+        mail_parts._list.append(b)
+        c = BodyMailPart('c', BodyMailPartType.Signature)
+        mail_parts._list.append(c)
+        mail_parts.disable_signature()
+        assert len(mail_parts) == 3
+        assert mail_parts[2].text == 'c'
+        assert mail_parts[2].part_type == BodyMailPartType.Main
+
+    def test_unit__disable_signature_sign_main_as_previous_elem(self):
+        mail_parts = BodyMailParts()
+        a = BodyMailPart('a', BodyMailPartType.Quote)
+        mail_parts._list.append(a)
+        b = BodyMailPart('b', BodyMailPartType.Main)
+        mail_parts._list.append(b)
+        c = BodyMailPart('c', BodyMailPartType.Signature)
+        mail_parts._list.append(c)
+        mail_parts.disable_signature()
+        assert len(mail_parts) == 2
+        assert mail_parts[1].text == 'bc'
+        assert mail_parts[1].part_type == BodyMailPartType.Main
+
+    def test_unit__drop_part_type(self):
+        mail_parts = BodyMailParts()
+        a = BodyMailPart('a', BodyMailPartType.Main)
+        mail_parts._list.append(a)
+        b = BodyMailPart('b', BodyMailPartType.Quote)
+        mail_parts._list.append(b)
+        c = BodyMailPart('c', BodyMailPartType.Signature)
+        mail_parts._list.append(c)
+        mail_parts.drop_part_type(BodyMailPartType.Quote)
+        assert len(mail_parts) == 2
+        assert mail_parts[0].text == 'a'
+        assert mail_parts[0].part_type == BodyMailPartType.Main
+        assert len(mail_parts) == 2
+        assert mail_parts[1].text == 'c'
+        assert mail_parts[1].part_type == BodyMailPartType.Signature
+
+    def test_unit__drop_part_type_consistence(self):
+        mail_parts = BodyMailParts()
+        a = BodyMailPart('a', BodyMailPartType.Main)
+        mail_parts._list.append(a)
+        b = BodyMailPart('b', BodyMailPartType.Quote)
+        mail_parts._list.append(b)
+        c = BodyMailPart('c', BodyMailPartType.Main)
+        mail_parts._list.append(c)
+        mail_parts.drop_part_type(BodyMailPartType.Quote)
+        assert len(mail_parts) == 1
+        assert mail_parts[0].text == 'ac'
+        assert mail_parts[0].part_type == BodyMailPartType.Main
+
+    def test_unit__get_nb_part_type(self):
+        mail_parts = BodyMailParts()
+        assert mail_parts.get_nb_part_type(BodyMailPartType.Main) == 0
+        assert mail_parts.get_nb_part_type(BodyMailPartType.Quote) == 0
+        assert mail_parts.get_nb_part_type(BodyMailPartType.Signature) == 0
+        a = BodyMailPart('a', BodyMailPartType.Main)
+        mail_parts._list.append(a)
+        assert mail_parts.get_nb_part_type(BodyMailPartType.Main) == 1
+        b = BodyMailPart('b', BodyMailPartType.Quote)
+        mail_parts._list.append(b)
+        assert mail_parts.get_nb_part_type(BodyMailPartType.Quote) == 1
+        c = BodyMailPart('c', BodyMailPartType.Signature)
+        mail_parts._list.append(c)
+        assert mail_parts.get_nb_part_type(BodyMailPartType.Main) == 1
+        assert mail_parts.get_nb_part_type(BodyMailPartType.Quote) == 1
+        assert mail_parts.get_nb_part_type(BodyMailPartType.Signature) == 1
+
+    def test_unit__str(self):
+        mail_parts = BodyMailParts()
+        a = BodyMailPart('a', BodyMailPartType.Main)
+        mail_parts._list.append(a)
+        b = BodyMailPart('b', BodyMailPartType.Quote)
+        mail_parts._list.append(b)
+        c = BodyMailPart('c', BodyMailPartType.Signature)
+        mail_parts._list.append(c)
+        assert str(mail_parts) == 'abc'
+
+
+class TestParsedMail(TestStandard):
+
+    def test_other__check_gmail_mail(self):
+        text_only = '''<div dir="ltr">Voici le texte<br></div>'''
+        mail = ParsedHTMLMail(text_only)
+        elements = mail.get_elements()
+        assert len(elements) == 1
+        assert elements[0].part_type == BodyMailPartType.Main
+
+        text_and_signature = '''
+        <div dir="ltr">POF<br clear="all"><div><br>-- <br>
+        <div class="gmail_signature" data-smartmail="gmail_signature">
+        <div dir="ltr">Voici Ma signature. En HTML <br><ol>
+        <li>Plop</li>
+        <li>Plip</li>
+        <li>Plop<br>
+        </li></ol></div></div></div></div>
+        '''
+        mail = ParsedHTMLMail(text_and_signature)
+        elements = mail.get_elements()
+        assert len(elements) == 2
+        assert elements[0].part_type == BodyMailPartType.Main
+        assert elements[1].part_type == BodyMailPartType.Signature
+
+        text_and_quote = '''
+        <div dir="ltr">Réponse<br>
+        <div class="gmail_extra"><br>
+        <div class="gmail_quote">Le 28 novembre 2017 à 10:29, John Doe <span
+        dir="ltr">&lt;<a href="mailto:bidule@localhost.fr"
+        target="_blank">bidule@localhost.fr</a>&gt;</span>
+        a écrit :<br>
+        <blockquote class="gmail_quote" style="margin:0 0 0
+        .8ex;border-left:1px #ccc solid;padding-left:1ex">Voici ma réponse<br>
+        <br><br>
+        Le 28/11/2017 à 10:05, Foo Bar a écrit&nbsp;:<br>
+        <blockquote class="gmail_quote" style="margin:0 0 0
+        .8ex;border-left:1px #ccc solid;padding-left:1ex">
+        Voici le texte<span class="HOEnZb"><font color="#888888"><br>
+        </font></span></blockquote>
+        <span class="HOEnZb"><font color="#888888">
+        <br>
+        -- <br>
+        TEST DE signature<br>
+        </font></span></blockquote>
+        </div><br></div></div>
+        '''
+        mail = ParsedHTMLMail(text_and_quote)
+        elements = mail.get_elements()
+        assert len(elements) == 2
+        assert elements[0].part_type == BodyMailPartType.Main
+        assert elements[1].part_type == BodyMailPartType.Quote
+
+        text_quote_text = '''
+              <div dir="ltr">Avant<br>
+              <div class="gmail_extra"><br>
+              <div class="gmail_quote">Le 28 novembre 2017 à 10:29, John Doe 
+              <span dir="ltr">&lt;<a href="mailto:bidule@localhost.fr"
+              target="_blank">bidule@localhost.fr</a>&gt;</span>
+              a écrit :<br>
+              <blockquote class="gmail_quote" style="margin:0 0 0
+              .8ex;border-left:1px #ccc solid;padding-left:1ex">Voici ma
+              réponse<br>
+              <br>
+              <br>
+              Le 28/11/2017 à 10:05, Foo Bar a écrit&nbsp;:<br>
+              <blockquote class="gmail_quote" style="margin:0 0 0
+              .8ex;border-left:1px #ccc solid;padding-left:1ex">
+              Voici le texte<span class="HOEnZb"><font color="#888888"><br>
+              </font></span></blockquote>
+              <span class="HOEnZb"><font color="#888888">
+              <br>
+              -- <br>
+              TEST DE signature<br>
+              </font></span></blockquote>
+              </div>
+              <br>
+              </div>
+              <div class="gmail_extra">Aprés<br>
+              </div>
+              </div>
+              '''
+
+        mail = ParsedHTMLMail(text_quote_text)
+        elements = mail.get_elements()
+        assert len(elements) == 3
+        assert elements[0].part_type == BodyMailPartType.Main
+        assert elements[1].part_type == BodyMailPartType.Quote
+        assert elements[2].part_type == BodyMailPartType.Main
+
+
+        text_quote_signature = '''
+        <div dir="ltr">Hey !<br>
+                 </div>
+                 <div class="gmail_extra"><br>
+                 <div class="gmail_quote">Le 28 novembre 2017 à 10:29,
+                  John Doe <span
+                 dir="ltr">&lt;<a href="mailto:bidule@localhost.fr"
+                 target="_blank">bidule@localhost.fr</a>&gt;</span>
+                 a écrit :<br>
+                 <blockquote class="gmail_quote" style="margin:0 0 0
+                 .8ex;border-left:1px #ccc solid;padding-left:1ex">Voici ma
+                 réponse<br>
+                 <br>
+                 <br>
+                  Le 28/11/2017 à 10:05, Foo Bar a écrit&nbsp;:<br>
+                  <blockquote class="gmail_quote" style="margin:0 0 0
+                  .8ex;border-left:1px #ccc solid;padding-left:1ex">
+                  Voici le texte<span class="HOEnZb"><font color="#888888"><br>
+                  </font></span></blockquote>
+                  <span class="HOEnZb"><font color="#888888">
+                  <br>
+                  -- <br>
+                  TEST DE signature<br>
+                  </font></span></blockquote>
+                  </div>
+                  <br>
+                  <br clear="all">
+                  <br>
+                  -- <br>
+                  <div class="gmail_signature" data-smartmail="gmail_signature">
+                  <div dir="ltr">Voici Ma signature. En HTML <br>
+                  <ol>
+                  <li>Plop</li>
+                  <li>Plip</li>
+                  <li>Plop<br>
+                  </li>
+                  </ol>
+                  </div>
+                  </div>
+                  </div>
+                 '''
+
+        # INFO - G.M - 2017-11-28 -
+        # Now Quote + Signature block in Gmail is considered as one Quote
+        # Block.
+        mail = ParsedHTMLMail(text_quote_signature)
+        elements = mail.get_elements()
+        assert len(elements) == 2
+        assert elements[0].part_type == BodyMailPartType.Main
+        assert elements[1].part_type == BodyMailPartType.Quote
+
+        text_quote_text_sign = '''
+        <div dir="ltr">Test<br>
+        <div class="gmail_extra"><br>
+        <div class="gmail_quote">Le 28 novembre 2017 à 10:29, John Doe <span
+        dir="ltr">&lt;<a href="mailto:bidule@localhost.fr"
+        target="_blank">bidule@localhost.fr</a>&gt;</span>
+        a écrit :<br>
+        <blockquote class="gmail_quote" style="margin:0 0 0
+        .8ex;border-left:1px #ccc solid;padding-left:1ex">Voici ma
+        réponse<br>
+        <br>
+        <br>
+        Le 28/11/2017 à 10:05, Foo Bar a écrit&nbsp;:<br>
+        <blockquote class="gmail_quote" style="margin:0 0 0
+        .8ex;border-left:1px #ccc solid;padding-left:1ex">
+        Voici le texte<span class="HOEnZb"><font color="#888888"><br>
+        </font></span></blockquote>
+        <span class="HOEnZb"><font color="#888888">
+        <br>
+        -- <br>
+        TEST DE signature<br>
+        </font></span></blockquote>
+        </div>
+        <br>
+        <br>
+        </div>
+        <div class="gmail_extra">RE test<br clear="all">
+        </div>
+        <div class="gmail_extra"><br>
+        -- <br>
+        <div class="gmail_signature" data-smartmail="gmail_signature">
+        <div dir="ltr">Voici Ma signature. En HTML <br>
+        <ol>
+        <li>Plop</li>
+        <li>Plip</li>
+        <li>Plop<br>
+        </li>
+        </ol>
+        </div>
+        </div>
+        </div>
+        </div>
+        '''
+
+        mail = ParsedHTMLMail(text_quote_text_sign)
+        elements = mail.get_elements()
+        assert len(elements) == 4
+        assert elements[0].part_type == BodyMailPartType.Main
+        assert elements[1].part_type == BodyMailPartType.Quote
+        assert elements[2].part_type == BodyMailPartType.Main
+        assert elements[3].part_type == BodyMailPartType.Signature
+
+    def test_other__check_thunderbird_mail(self):
+
+        text_only = '''Coucou<br><br><br>'''
+        mail = ParsedHTMLMail(text_only)
+        elements = mail.get_elements()
+        assert len(elements) == 1
+        assert elements[0].part_type == BodyMailPartType.Main
+
+        text_and_signature = '''
+        <p>Test<br>
+        </p>
+        <div class="moz-signature">-- <br>
+          TEST DE signature</div>
+        '''
+        mail = ParsedHTMLMail(text_and_signature)
+        elements = mail.get_elements()
+        assert len(elements) == 2
+        assert elements[0].part_type == BodyMailPartType.Main
+        assert elements[1].part_type == BodyMailPartType.Signature
+
+        text_and_quote = '''
+            <p>Pof<br>
+            </p>
+            <br>
+            <div class="moz-cite-prefix">Le 28/11/2017 à 11:21, John Doe a
+              écrit&nbsp;:<br>
+            </div>
+            <blockquote type="cite"
+              cite="mid:658592c1-14de-2958-5187-3571edea0aac@localhost.fr">
+              <meta http-equiv="Context-Type" 
+              content="text/html; charset=utf-8">
+              <p>Test<br>
+              </p>
+              <div class="moz-signature">-- <br>
+                TEST DE signature</div>
+            </blockquote>
+            <br>
+        '''
+        mail = ParsedHTMLMail(text_and_quote)
+        elements = mail.get_elements()
+        assert len(elements) == 2
+        assert elements[0].part_type == BodyMailPartType.Main
+        assert elements[1].part_type == BodyMailPartType.Quote
+
+        text_quote_text = '''
+        <p>Pof<br>
+        </p>
+        <br>
+        <div class="moz-cite-prefix">Le 28/11/2017 à 11:54, 
+         Bidule a
+          écrit&nbsp;:<br>
+        </div>
+        <blockquote type="cite"
+          cite="mid:b541b451-bb31-77a4-45b9-ad89969d7962@localhost.fr">
+          <meta http-equiv="Context-Type" 
+          content="text/html; charset=utf-8">
+          <p>Pof<br>
+          </p>
+          <br>
+          <div class="moz-cite-prefix">Le 28/11/2017 à 11:21, John Doe a
+            écrit&nbsp;:<br>
+          </div>
+          <blockquote type="cite"
+            cite="mid:658592c1-14de-2958-5187-3571edea0aac@localhost.fr">
+            <p>Test<br>
+            </p>
+            <div class="moz-signature">-- <br>
+              TEST DE signature</div>
+          </blockquote>
+          <br>
+        </blockquote>
+        Pif<br>
+        '''
+
+        mail = ParsedHTMLMail(text_quote_text)
+        elements = mail.get_elements()
+        assert len(elements) == 3
+        assert elements[0].part_type == BodyMailPartType.Main
+        assert elements[1].part_type == BodyMailPartType.Quote
+        assert elements[2].part_type == BodyMailPartType.Main
+
+        text_quote_signature = '''
+        <p>Coucou<br>
+        </p>
+        <br>
+        <div class="moz-cite-prefix">Le 28/11/2017 à 11:22, Bidule a
+        écrit&nbsp;:<br>
+        </div>
+        <blockquote type="cite"
+        cite="mid:4e6923e2-796d-eccf-84b7-6824da4151ee@localhost.fr">Réponse <br>
+        <br>
+        Le 28/11/2017 à 11:21, John Doe a écrit&nbsp;: <br>
+        <blockquote type="cite"> <br>
+        Test <br>
+        <br>
+        --&nbsp;<br>
+        TEST DE signature <br>
+        </blockquote>
+        <br>
+        </blockquote>
+        <br>
+        <div class="moz-signature">-- <br>
+        TEST DE signature</div>
+        '''
+
+        mail = ParsedHTMLMail(text_quote_signature)
+        elements = mail.get_elements()
+        assert len(elements) == 3
+        assert elements[0].part_type == BodyMailPartType.Main
+        assert elements[1].part_type == BodyMailPartType.Quote
+        assert elements[2].part_type == BodyMailPartType.Signature
+
+        text_quote_text_sign = '''
+        <p>Avant<br>
+        </p>
+        <br>
+        <div class="moz-cite-prefix">Le 28/11/2017 à 11:19, Bidule a
+          écrit&nbsp;:<br>
+        </div>
+        <blockquote type="cite"
+          cite="mid:635df73c-d3c9-f2e9-2304-24ff536bfa16@localhost.fr">Coucou 
+          <br><br>
+        </blockquote>
+        Aprés<br>
+        <br>
+        <div class="moz-signature">-- <br>
+          TEST DE signature</div>
+        '''
+
+        mail = ParsedHTMLMail(text_quote_text_sign)
+        elements = mail.get_elements()
+        assert len(elements) == 4
+        assert elements[0].part_type == BodyMailPartType.Main
+        assert elements[1].part_type == BodyMailPartType.Quote
+        assert elements[2].part_type == BodyMailPartType.Main
+        assert elements[3].part_type == BodyMailPartType.Signature
+
+