[IMP] phone_validation: add blacklist mechanism

PURPOSE

SMS are a powerful marketing tool. For instance it is perfect to announce a
sale or to communicate a coupon code, to welcome a new customer in a fidelity
program, ...

Purpose of this task is to integrate SMS sending in batch in mass mailing. It
will use same mailing objects but sending SMS instead of emails. Some metrics
and flows will have to be slightly updated at the same time.

SPECIFICATIONS

Purpose of this commit is to add a blacklist mechanism for phone numbers
used to send SMS like what already exists for email addresses when sending
emails.

Define a new phone.blacklist model, holding a number and the state of the
blacklist (active field), as well as tools methods to access it. Make it
as private as possible, accessing it in sudo once access are granted.

Also clean phone validation tools: lessen number of tool functions and update
caller to simplify code readability. Some fixes are also included in this
commit, notably blank spaces cleaning in phone numbers.

Improve phone.validation.mixin to add a tool method computing a sanitized
number, in addition to formatting it to national / international.

Define a new mail.thread.phone mixin computing the blacklist status of a
record. This mixin

  * inherit from phone.validation.mixin in order to have access to some
    base phone number parsing capabilities;
  * computes a sanitized phone number based on ´´_phone_get_number_fields´´.
    It takes first sanitized value, trying each field returned by the
    method. That means one sanitized phone number is available per record
    even if several fields are available;
  * compute blacklist state of records. It is based on phone.blacklist
    model and give an easy-to-use field and API to manipulate blacklisted
    records;
  * give some API methods :

    * ``_phone_set_blacklisted``: set recordset as blacklisted;
    * ``_phone_reset_blacklisted``: reactivate recordset (even if not blacklisted
        this method can be called safely);

Put menus in technical in order to have access to it. Add a Phone / SMS
menu below "Email" and use it to store SMS / Phone actions.

Finally prepare tests addition by performing some light cleaning while adding
blacklist tests. Purpose is to ease future tests related to SMS.

LINKS

Task 1997464
PR #34424
Original SMS addition: Task 1922163 (4287481)

addons/phone_validation/__manifest__.py

@@ -3,6 +3,7 @@
 
 {
     'name': 'Phone Numbers Validation',
+    'version': '2.0',
     'summary': 'Validate and format phone numbers',
     'sequence': '9999',
     'category': 'Hidden',
@@ -11,12 +12,24 @@ Phone Numbers Validation
 ========================
 
 This module adds the feature of validation and formatting phone numbers
-according to a destination country. It also handles national and international
-formatting.
+according to a destination country.
 
-This module applies this feature to Leads and Contacts.""",
+It also adds phone blacklist management through a specific model storing
+blacklisted phone numbers.
+
+It adds two mixins :
+
+  * phone.validation.mixin: parsing / formatting helpers on records, to be
+    used for example in number fields onchange;
+  * mail.thread.phone: handle sanitation and blacklist of records numbers;
+""",
     'data': [
-        'views/res_company_view.xml'
+        'security/ir.model.access.csv',
+        'views/res_company_view.xml',
+        'views/phone_blacklist_views.xml',
+    ],
+    'depends': [
+        'base',
+        'mail',
     ],
-    'depends': ['base'],
 }

addons/phone_validation/models/__init__.py

@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 
-from . import res_company
+from . import phone_blacklist
 from . import phone_validation_mixin
+from . import mail_thread_phone
+from . import res_company

addons/phone_validation/models/mail_thread_phone.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import api, fields, models, _
+from odoo.exceptions import UserError
+
+
+class PhoneMixin(models.AbstractModel):
+    """ Purpose of this mixin is to offer two services
+
+      * compute a sanitized phone number based on ´´_sms_get_number_fields´´.
+        It takes first sanitized value, trying each field returned by the
+        method (see ``MailThread._sms_get_number_fields()´´ for more details
+        about the usage of this method);
+      * compute blacklist state of records. It is based on phone.blacklist
+        model and give an easy-to-use field and API to manipulate blacklisted
+        records;
+
+    Main API methods
+
+      * ``_phone_set_blacklisted``: set recordset as blacklisted;
+      * ``_phone_reset_blacklisted``: reactivate recordset (even if not blacklisted
+        this method can be called safely);
+    """
+    _name = 'mail.thread.phone'
+    _description = 'Phone Blacklist Mixin'
+    _inherit = ['mail.thread', 'phone.validation.mixin']
+
+    phone_sanitized = fields.Char(
+        string='Sanitized Number', compute="_compute_phone_sanitized", compute_sudo=True, store=True,
+        help="Field used to store sanitized phone number. Helps speeding up searches and comparisons.")
+    phone_blacklisted = fields.Boolean(
+        string='Phone Blacklisted', compute="_compute_phone_blacklisted", compute_sudo=True, store=False,
+        search="_search_phone_blacklisted", groups="base.group_user",
+        help="If the email address is on the blacklist, the contact won't receive mass mailing anymore, from any list")
+
+    @api.depends(lambda self: self._phone_get_number_fields())
+    def _compute_phone_sanitized(self):
+        self._assert_phone_field()
+        number_fields = self._phone_get_number_fields()
+        for record in self:
+            for fname in number_fields:
+                sanitized = record.phone_get_sanitized_number(number_fname=fname)
+                if sanitized:
+                    break
+            record.phone_sanitized = sanitized
+
+    @api.depends('phone_sanitized')
+    def _compute_phone_blacklisted(self):
+        # TODO : Should remove the sudo as compute_sudo defined on methods.
+        # But if user doesn't have access to mail.blacklist, doen't work without sudo().
+        blacklist = set(self.env['phone.blacklist'].sudo().search([
+            ('number', 'in', self.mapped('phone_sanitized'))]).mapped('number'))
+        for record in self:
+            record.phone_blacklisted = record.phone_sanitized in blacklist
+
+    @api.model
+    def _search_phone_blacklisted(self, operator, value):
+        # Assumes operator is '=' or '!=' and value is True or False
+        self._assert_phone_field()
+        if operator != '=':
+            if operator == '!=' and isinstance(value, bool):
+                value = not value
+            else:
+                raise NotImplementedError()
+
+        if value:
+            query = """
+                SELECT m.id
+                    FROM phone_blacklist bl
+                    JOIN %s m
+                    ON m.phone_sanitized = bl.number AND bl.active
+            """
+        else:
+            query = """
+                SELECT m.id
+                    FROM %s m
+                    LEFT JOIN phone_blacklist bl
+                    ON m.phone_sanitized = bl.number AND bl.active
+                    WHERE bl.id IS NULL
+            """
+        self._cr.execute(query % self._table)
+        res = self._cr.fetchall()
+        if not res:
+            return [(0, '=', 1)]
+        return [('id', 'in', [r[0] for r in res])]
+
+    def _assert_phone_field(self):
+        if not hasattr(self, "_phone_get_number_fields"):
+            raise UserError(_('Invalid primary phone field on model %s') % self._name)
+        if not any(fname in self and self._fields[fname].type == 'char' for fname in self._phone_get_number_fields()):
+            raise UserError(_('Invalid primary phone field on model %s') % self._name)
+
+    def _phone_get_number_fields(self):
+        """ This method returns the fields to use to find the number to use to
+        send an SMS on a record. """
+        return []
+
+    def _phone_set_blacklisted(self):
+        return self.env['phone.blacklist'].sudo()._add([r.phone_sanitized for r in self])
+
+    def _phone_reset_blacklisted(self):
+        return self.env['phone.blacklist'].sudo()._remove([r.phone_sanitized for r in self])

addons/phone_validation/models/phone_blacklist.py

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import logging
+
+from odoo import api, fields, models, _
+from odoo.addons.phone_validation.tools import phone_validation
+from odoo.exceptions import UserError
+
+_logger = logging.getLogger(__name__)
+
+
+class PhoneBlackList(models.Model):
+    """ Blacklist of phone numbers. Used to avoid sending unwanted messages to people. """
+    _name = 'phone.blacklist'
+    _inherit = ['mail.thread']
+    _description = 'Phone Blacklist'
+    _rec_name = 'number'
+
+    number = fields.Char(string='Phone Number', required=True, index=True, tracking=True, help='Number should be E164 formatted')
+    active = fields.Boolean(default=True, tracking=True)
+
+    _sql_constraints = [
+        ('unique_number', 'unique (number)', 'Number already exists')
+    ]
+
+    @api.model_create_multi
+    def create(self, values):
+        # First of all, extract values to ensure emails are really unique (and don't modify values in place)
+        to_create = []
+        done = set()
+        for value in values:
+            number = value['number']
+            sanitized = phone_validation.phone_sanitize_numbers_w_record([number], self.env.user)[number]['sanitized']
+            if not sanitized:
+                raise UserError(_('Invalid number %s') % number)
+            if sanitized in done:
+                continue
+            done.add(sanitized)
+            to_create.append(dict(value, number=sanitized))
+
+        """ To avoid crash during import due to unique email, return the existing records if any """
+        sql = '''SELECT number, id FROM phone_blacklist WHERE number = ANY(%s)'''
+        numbers = [v['number'] for v in to_create]
+        self._cr.execute(sql, (numbers,))
+        bl_entries = dict(self._cr.fetchall())
+        to_create = [v for v in to_create if v['number'] not in bl_entries]
+
+        results = super(PhoneBlackList, self).create(to_create)
+        return self.env['phone.blacklist'].browse(bl_entries.values()) | results
+
+    def write(self, values):
+        if 'number' in values:
+            number = values['number']
+            sanitized = phone_validation.phone_sanitize_numbers_w_record([number], self.env.user)[number]['sanitized']
+            if not sanitized:
+                raise UserError(_('Invalid number %s') % number)
+            values['number'] = sanitized
+        return super(PhoneBlackList, self).write(values)
+
+    def _search(self, args, offset=0, limit=None, order=None, count=False, access_rights_uid=None):
+        """ Override _search in order to grep search on sanitized number field """
+        if args:
+            new_args = []
+            for arg in args:
+                if isinstance(arg, (list, tuple)) and arg[0] == 'number' and isinstance(arg[2], str):
+                    number = arg[2]
+                    sanitized = phone_validation.phone_sanitize_numbers_w_record([number], self.env.user)[number]['sanitized']
+                    if sanitized:
+                        new_args.append([arg[0], arg[1], sanitized])
+                    else:
+                        new_args.append(arg)
+                else:
+                    new_args.append(arg)
+        else:
+            new_args = args
+        return super(PhoneBlackList, self)._search(new_args, offset=offset, limit=limit, order=order, count=count, access_rights_uid=access_rights_uid)
+
+    def add(self, number):
+        sanitized = phone_validation.phone_sanitize_numbers_w_record([number], self.env.user)[number]['sanitized']
+        return self._add([sanitized])
+
+    def _add(self, numbers):
+        """ Add or re activate a phone blacklist entry.
+
+        :param numbers: list of sanitized numbers """
+        records = self.env["phone.blacklist"].with_context(active_test=False).search([('number', 'in', numbers)])
+        todo = [n for n in numbers if n not in records.mapped('number')]
+        if records:
+            records.write({'active': True})
+        if todo:
+            records += self.create([{'number': n} for n in todo])
+        return records
+
+    def remove(self, number):
+        sanitized = phone_validation.phone_sanitize_numbers_w_record([number], self.env.user)[number]['sanitized']
+        return self._remove([sanitized])
+
+    def _remove(self, numbers):
+        """ Add de-activated or de-activate a phone blacklist entry.
+
+        :param numbers: list of sanitized numbers """
+        records = self.env["phone.blacklist"].with_context(active_test=False).search([('number', 'in', numbers)])
+        todo = [n for n in numbers if n not in records.mapped('number')]
+        if records:
+            records.write({'active': False})
+        if todo:
+            records += self.create([{'number': n, 'active': False} for n in todo])
+        return records

addons/phone_validation/models/phone_validation_mixin.py

@@ -9,6 +9,11 @@ class PhoneValidationMixin(models.AbstractModel):
     _name = 'phone.validation.mixin'
     _description = 'Phone Validation Mixin'
 
+    def _phone_get_country_field(self):
+        if 'country_id' in self:
+            return 'country_id'
+        return False
+
     def _phone_get_country(self):
         if 'country_id' in self and self.country_id:
             return self.country_id
@@ -31,3 +36,17 @@ class PhoneValidationMixin(models.AbstractModel):
             force_format='INTERNATIONAL' if always_international else 'NATIONAL',
             raise_exception=False
         )
+
+    def phone_get_sanitized_numbers(self, number_fname='mobile', force_format='E164'):
+        res = dict.fromkeys(self.ids, False)
+        country_fname = self._phone_get_country_field()
+        for record in self:
+            number = record[number_fname]
+            res[record.id] = phone_validation.phone_sanitize_numbers_w_record([number], record, record_country_fname=country_fname, force_format=force_format)[number]['sanitized']
+        return res
+
+    def phone_get_sanitized_number(self, number_fname='mobile', force_format='E164'):
+        self.ensure_one()
+        country_fname = self._phone_get_country_field()
+        number = self[number_fname]
+        return phone_validation.phone_sanitize_numbers_w_record([number], self, record_country_fname=country_fname, force_format=force_format)[number]['sanitized']

addons/phone_validation/security/ir.model.access.csv

@@ -0,0 +1,3 @@
+id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
+access_phone_blacklist_all,access.phone.blacklist.all,model_phone_blacklist,,0,0,0,0
+access_phone_blacklist_system,access.phone.blacklist.system,model_phone_blacklist,base.group_system,1,1,1,1

addons/phone_validation/tools/phone_validation.py

@@ -17,7 +17,7 @@ try:
         try:
             phone_nbr = phonenumbers.parse(number, region=country_code, keep_raw_input=True)
         except phonenumbers.phonenumberutil.NumberParseException as e:
-            raise UserError(_('Unable to parse %s:\n%s') % (number, e))
+            raise UserError(_('Unable to parse %s: %s') % (number, str(e)))
 
         if not phonenumbers.is_possible_number(phone_nbr):
             raise UserError(_('Impossible number %s: probably invalid number of digits') % number)
@@ -77,45 +77,41 @@ except ImportError:
 
 
 def phone_sanitize_numbers(numbers, country_code, country_phone_code, force_format='E164'):
+    """ Given a list of numbers, return parsezd and sanitized information
+
+    :return dict: {number: {
+        'sanitized': sanitized and formated number or False (if cannot format)
+        'code': 'empty' (number was a void string), 'invalid' (error) or False (sanitize ok)
+        'msg': error message when 'invalid'
+    }}
+    """
+    if not isinstance(numbers, (list)):
+        raise NotImplementedError()
     result = dict.fromkeys(numbers, False)
     for number in numbers:
         if not number:
             result[number] = {'sanitized': False, 'code': 'empty', 'msg': False}
             continue
         try:
+            stripped = number.strip()
             sanitized = phone_format(
-                number, country_code, country_phone_code,
+                stripped, country_code, country_phone_code,
                 force_format=force_format, raise_exception=True)
         except Exception as e:
-            result[number] = {'sanitized': False, 'code': 'invalid', 'msg': e}
+            result[number] = {'sanitized': False, 'code': 'invalid', 'msg': str(e)}
         else:
             result[number] = {'sanitized': sanitized, 'code': False, 'msg': False}
     return result
 
 
 def phone_sanitize_numbers_w_record(numbers, record, country=False, record_country_fname='country_id', force_format='E164'):
+    if not isinstance(numbers, (list)):
+        raise NotImplementedError()
     if not country:
-        if record and hasattr(record, record_country_fname) and record[record_country_fname]:
+        if record and record_country_fname and hasattr(record, record_country_fname) and record[record_country_fname]:
             country = record[record_country_fname]
         elif record:
             country = record.env.company.country_id
     country_code = country.code if country else None
     country_phone_code = country.phone_code if country else None
     return phone_sanitize_numbers(numbers, country_code, country_phone_code, force_format=force_format)
-
-
-def phone_sanitize_numbers_string_w_record(numbers_str, record, country=False, record_country_fname='country_id', force_format='E164'):
-    found_numbers = [number.strip() for number in numbers_str.split(',')]
-    return phone_sanitize_numbers_w_record(found_numbers, record, country=country, record_country_fname=record_country_fname, force_format=force_format)
-
-
-def phone_get_sanitized_records_number(records, number_fname='mobile', country_fname='country_id', force_format='E164'):
-    res = dict.fromkeys(records.ids, False)
-    for record in records:
-        number = record[number_fname]
-        res[record.id] = phone_sanitize_numbers_w_record([number], records, record_country_fname=country_fname,force_format=force_format)[number]['sanitized']
-    return res
-
-
-def phone_get_sanitized_record_number(record, number_fname='mobile', country_fname='country_id', force_format='E164'):
-    return phone_get_sanitized_records_number(record, number_fname, country_fname, force_format=force_format)[record.id]

addons/phone_validation/views/phone_blacklist_views.xml

@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<odoo>
+    <record id="phone_blacklist_view_tree" model="ir.ui.view">
+        <field name="name">phone.blacklist.view.tree</field>
+        <field name="model">phone.blacklist</field>
+        <field name="arch" type="xml">
+            <tree string="Phone Blacklist">
+                <field name="create_date" string="Blacklist Date"/>
+                <field name="number"/>
+            </tree>
+        </field>
+    </record>
+
+    <record id="phone_blacklist_view_form" model="ir.ui.view">
+        <field name="name">phone.blacklist.view.form</field>
+        <field name="model">phone.blacklist</field>
+        <field name="arch" type="xml">
+            <form string="Phone Blacklist" duplicate="false" edit="false">
+                <sheet>
+                    <group>
+                        <group>
+                            <field name="number"/>
+                            <field name="active"/>
+                        </group>
+                    </group>
+                </sheet>
+                <div class="oe_chatter">
+                    <field name="message_follower_ids" widget="mail_followers"/>
+                    <field name="message_ids" widget="mail_thread"/>
+                </div>
+            </form>
+        </field>
+    </record>
+
+    <record id="phone_blacklist_view_search" model="ir.ui.view">
+        <field name="name">phone.blacklist.view.search</field>
+        <field name="model">phone.blacklist</field>
+        <field name="arch" type="xml">
+            <search>
+                <field name="number"/>
+                <filter string="Archived" name="inactive" domain="[('active','=',False)]"/>
+            </search>
+        </field>
+    </record>
+
+    <record id="phone_blacklist_action" model="ir.actions.act_window">
+        <field name="name">Phone Blacklist</field>
+        <field name="res_model">phone.blacklist</field>
+        <field name="view_id" ref="phone_blacklist_view_tree"/>
+        <field name="search_view_id" ref="phone_blacklist_view_search"/>
+        <field name="help" type="html">
+            <p class="o_view_nocontent_smiling_face">
+                Add a phone number in the blacklist
+            </p><p>
+                Blacklisted phone numbers means that the recipient won't receive mass SMS anymore.
+            </p>
+        </field>
+    </record>
+
+    <!-- Technical Menu -->
+    <menuitem id="phone_menu_main"
+        name="Phone / SMS"
+        parent="base.menu_custom"
+        sequence="2"/>
+
+    <menuitem id="phone_blacklist_menu"
+        name="Phone Blacklist"
+        parent="phone_validation.phone_menu_main"
+        sequence="3"
+        action="phone_blacklist_action"/>
+
+</odoo>

addons/sms/__manifest__.py

@@ -2,6 +2,7 @@
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 {
     'name': 'SMS gateway',
+    'version': '2.0',
     'category': 'Tools',
     'summary': 'SMS Text Messaging',
     'description': """
@@ -32,5 +33,5 @@ The service is provided by the In App Purchase Odoo platform.
         'static/src/xml/thread.xml',
     ],
     'installable': True,
-    'auto_install': True,
+    'auto_install': False,
 }

addons/sms/models/__init__.py

@@ -6,6 +6,7 @@ from . import mail_followers
 from . import mail_message
 from . import mail_notification
 from . import mail_thread
+from . import mail_thread_phone
 from . import res_partner
 from . import sms_api
 from . import sms_sms

addons/sms/models/mail_thread.py

@@ -78,7 +78,7 @@ class MailThread(models.AbstractModel):
 
             valid_number = False
             for fname in [f for f in tocheck_fields if f in record]:
-                valid_number = phone_validation.phone_get_sanitized_record_number(record, number_fname=fname)
+                valid_number = phone_validation.phone_sanitize_numbers_w_record([record[fname]], record)[record[fname]]['sanitized']
                 if valid_number:
                     break
 
@@ -92,7 +92,7 @@ class MailThread(models.AbstractModel):
                 for partner in all_partners:
                     partner_number = partner.mobile or partner.phone
                     if partner_number:
-                        partner_number = phone_validation.phone_sanitize_numbers_string_w_record(partner_number, record)[partner_number]['sanitized']
+                        partner_number = phone_validation.phone_sanitize_numbers_w_record([partner_number], record)[partner_number]['sanitized']
                     if partner_number:
                         break
 
@@ -233,7 +233,7 @@ class MailThread(models.AbstractModel):
         if partner_ids:
             for partner in self.env['res.partner'].sudo().browse(partner_ids):
                 number = sms_pid_to_number.get(partner.id) or partner.mobile or partner.phone
-                sanitize_res = phone_validation.phone_sanitize_numbers_string_w_record(number, partner)[number]
+                sanitize_res = phone_validation.phone_sanitize_numbers_w_record([number], partner)[number]
                 number = sanitize_res['sanitized'] or number
                 sms_create_vals.append(dict(
                     sms_base_vals,

addons/sms/models/mail_thread_phone.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import models
+
+
+class PhoneMixin(models.AbstractModel):
+    _inherit = 'mail.thread.phone'
+
+    def _phone_get_number_fields(self):
+        """ Add fields coming from sms implementation. """
+        sms_fields = self._sms_get_number_fields()
+        res = super(PhoneMixin, self)._phone_get_number_fields()
+        for fname in (f for f in res if f not in sms_fields):
+            sms_fields.append(fname)
+        return sms_fields

addons/sms/models/res_partner.py

@@ -5,7 +5,8 @@ from odoo import models
 
 
 class ResPartner(models.Model):
-    _inherit = 'res.partner'
+    _name = 'res.partner'
+    _inherit = ['res.partner', 'mail.thread.phone']
 
     def _sms_get_default_partners(self):
         """ Override of mail.thread method.

addons/sms/tests/common.py

@@ -74,7 +74,7 @@ class MockSMS(common.BaseCase):
         """ Check canceled SMS. Search is done for a pair partner / number where
         partner can be an empty recordset. """
         if number is None and partner:
-            number = phone_validation.phone_get_sanitized_record_number(partner)
+            number = partner.phone_get_sanitized_number()
         sms = self.env['sms.sms'].sudo().search([
             ('partner_id', '=', partner.id), ('number', '=', number),
             ('state', '=', 'canceled')
@@ -88,7 +88,7 @@ class MockSMS(common.BaseCase):
         """ Check failed SMS. Search is done for a pair partner / number where
         partner can be an empty recordset. """
         if number is None and partner:
-            number = phone_validation.phone_get_sanitized_record_number(partner)
+            number = partner.phone_get_sanitized_number()
         sms = self.env['sms.sms'].sudo().search([
             ('partner_id', '=', partner.id), ('number', '=', number),
             ('state', '=', 'error')
@@ -102,7 +102,7 @@ class MockSMS(common.BaseCase):
         """ Check outgoing SMS. Search is done for a pair partner / number where
         partner can be an empty recordset. """
         if number is None and partner:
-            number = phone_validation.phone_get_sanitized_record_number(partner)
+            number = partner.phone_get_sanitized_number()
         sms = self.env['sms.sms'].sudo().search([
             ('partner_id', '=', partner.id), ('number', '=', number),
             ('state', '=', 'outgoing')
@@ -139,7 +139,7 @@ class MockSMS(common.BaseCase):
             number = recipient_info.get('number')
             state = recipient_info.get('state', 'sent')
             if number is None and partner:
-                number = phone_validation.phone_get_sanitized_record_number(partner)
+                number = partner.phone_get_sanitized_number()
 
             notif = notifications.filtered(lambda n: n.res_partner_id == partner and n.sms_number == number and n.notification_status == state)
             self.assertTrue(notif, 'SMS: not found notification for %s (number: %s, state: %s)' % (partner, number, state))

addons/sms/views/res_partner_views.xml

@@ -8,6 +8,9 @@
         <field name="inherit_id" ref="base.view_partner_form"/>
         <field name="priority">10</field>
         <field name="arch" type="xml">
+            <xpath expr="//field[@name='mobile']" position="after">
+                <field name="phone_sanitized" groups="base.group_no_one"/>
+            </xpath>
             <xpath expr="//field[@name='phone']" position="replace">
                 <label for="phone"/>
                 <div class="o_row">

addons/sms/views/sms_sms_views.xml

@@ -59,8 +59,10 @@
         <field name="view_mode">tree,form</field>
     </record>
 
-    <menuitem id="sms_menu_main" name="SMS" parent="base.menu_custom" sequence="2"/>
-    <menuitem id="sms_sms_menu" parent="sms_menu_main" action="sms_sms_action" sequence="1"/>
+    <menuitem id="sms_sms_menu"
+        parent="phone_validation.phone_menu_main"
+        action="sms_sms_action"
+        sequence="1"/>
 
 </data>
 </odoo>

addons/sms/views/sms_template_views.xml

@@ -67,7 +67,11 @@
         <field name="view_mode">tree,form</field>
     </record>
 
-    <menuitem id="sms_template_menu" parent="sms_menu_main" action="sms_template_action"/>
+    <menuitem id="sms_template_menu"
+        name="SMS Templates"
+        parent="phone_validation.phone_menu_main"
+        sequence="2"
+        action="sms_template_action"/>
 
 </data>
 </odoo>

addons/sms/wizard/sms_composer.py

@@ -114,7 +114,8 @@ class SendSMS(models.TransientModel):
     def _compute_sanitized_numbers(self):
         if self.numbers:
             record = self._get_records() if self.res_model and self.res_id else self.env.user
-            sanitize_res = phone_validation.phone_sanitize_numbers_string_w_record(self.numbers, record)
+            numbers = [number.strip() for number in self.numbers.split(',')]
+            sanitize_res = phone_validation.phone_sanitize_numbers_w_record(numbers, record)
             sanitized_numbers = [info['sanitized'] for info in sanitize_res.values() if info['sanitized']]
             invalid_numbers = [number for number, info in sanitize_res.items() if info['code']]
             if invalid_numbers:

addons/test_mail_full/models/test_mail_models.py

@@ -26,6 +26,28 @@ class MailTestSMS(models.Model):
         return ['phone_nbr', 'mobile_nbr']
 
 
+class MailTestSMSBL(models.Model):
+    """ A model inheriting from mail.thread with some fields used for SMS
+    gateway, like a partner, a specific mobile phone, ... """
+    _description = 'Chatter Model for SMS Gateway'
+    _name = 'mail.test.sms.bl'
+    _inherit = ['mail.thread.phone']
+    _order = 'name asc, id asc'
+
+    name = fields.Char()
+    subject = fields.Char()
+    email_from = fields.Char()
+    phone_nbr = fields.Char()
+    mobile_nbr = fields.Char()
+    customer_id = fields.Many2one('res.partner', 'Customer')
+
+    def _sms_get_default_partners(self):
+        return self.mapped('customer_id')
+
+    def _sms_get_number_fields(self):
+        return ['phone_nbr', 'mobile_nbr']
+
+
 class MailTestSMSSoLike(models.Model):
     """ A model like sale order having only a customer, not specific phone
     or mobile fields. """

addons/test_mail_full/security/ir.model.access.csv

@@ -1,5 +1,7 @@
 id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
 access_mail_test_sms_all,mail.test.sms.all,model_mail_test_sms,,0,0,0,0
 access_mail_test_sms_user,mail.test.sms.user,model_mail_test_sms,base.group_user,1,1,1,1
+access_mail_test_sms_bl_all,mail.test.sms.bl.all,model_mail_test_sms_bl,,0,0,0,0
+access_mail_test_sms_bl_user,mail.test.sms.bl.user,model_mail_test_sms_bl,base.group_user,1,1,1,1
 access_mail_test_sms_partner_all,mail.test.sms.partner.all,model_mail_test_sms_partner,,0,0,0,0
 access_mail_test_sms_partner_user,mail.test.sms.partner.user,model_mail_test_sms_partner,base.group_user,1,1,1,1

addons/test_mail_full/tests/__init__.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 from . import common
+from . import test_phone_blacklist
 from . import test_sms_composer
 from . import test_sms_management
 from . import test_sms_performance

addons/test_mail_full/tests/common.py

@@ -24,3 +24,41 @@ class BaseFunctionalTest(test_mail_common.BaseFunctionalTest):
         # some numbers for mass testing
         cls.mass_numbers = ['04561%s2%s3%s' % (x, x, x) for x in range(0, 10)]
         cls.mass_numbers_san = [phone_validation.phone_format(number, 'BE', '32', force_format='E164') for number in cls.mass_numbers]
+
+    @classmethod
+    def _create_sms_template(cls, model, body=False):
+        return cls.env['sms.template'].create({
+            'name': 'Test Template',
+            'model_id': cls.env['ir.model']._get(model).id,
+            'body': body if body else 'Dear ${object.display_name} this is an SMS.'
+        })
+
+    @classmethod
+    def _create_records_for_batch(cls, model, count):
+        records = cls.env['mail.test.sms']
+        partners = cls.env['res.partner']
+        country_id = cls.env.ref('base.be').id,
+        for x in range(count):
+            partners += cls.env['res.partner'].with_context(**cls._test_context).create({
+                'name': 'Partner_%s' % (x),
+                'email': '_test_partner_%s@example.com' % (x),
+                'country_id': country_id,
+                'mobile': '047500%02d%02d' % (x, x)
+            })
+            records += cls.env[model].with_context(**cls._test_context).create({
+                'name': 'Test_%s' % (x),
+                'customer_id': partners[x].id,
+            })
+        cls.records = cls._reset_mail_context(records)
+        cls.partners = partners
+
+
+class TestRecipients(test_mail_common.TestRecipients):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestRecipients, cls).setUpClass()
+        cls.partner_numbers = [
+            phone_validation.phone_format(partner.mobile, partner.country_id.code, partner.country_id.phone_code, force_format='E164')
+            for partner in (cls.partner_1 | cls.partner_2)
+        ]

addons/test_mail_full/tests/test_phone_blacklist.py

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.addons.sms.tests import common as sms_common
+from odoo.addons.test_mail_full.tests import common as test_mail_full_common
+
+
+class TestPhoneBlacklist(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_full_common.TestRecipients):
+    """ TODO """
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestPhoneBlacklist, cls).setUpClass()
+        cls._test_body = 'VOID CONTENT'
+
+        cls.test_record = cls.env['mail.test.sms.bl'].with_context(**cls._test_context).create({
+            'name': 'Test',
+            'customer_id': cls.partner_1.id,
+            'mobile_nbr': cls.test_numbers[0],
+            'phone_nbr': cls.test_numbers[1],
+        })
+        cls.test_record = cls._reset_mail_context(cls.test_record)
+
+    def test_phone_blacklist_internals(self):
+        with self.sudo('employee'):
+            test_record = self.env['mail.test.sms.bl'].browse(self.test_record.id)
+            self.assertEqual(test_record.phone_sanitized, self.test_numbers_san[1])
+            self.assertFalse(test_record.phone_blacklisted)
+
+            bl_record = self.env['phone.blacklist'].sudo().create([{'number': self.test_numbers_san[1]}])
+            test_record.invalidate_cache()
+            self.assertTrue(test_record.phone_blacklisted)
+
+            self.env['phone.blacklist'].sudo().remove(self.test_numbers_san[1])
+            self.assertFalse(bl_record.active)
+            test_record.invalidate_cache()
+            self.assertFalse(test_record.phone_blacklisted)
+
+            self.env['phone.blacklist'].sudo().add(self.test_numbers_san[1])
+            self.assertTrue(bl_record.active)
+            test_record.invalidate_cache()
+            self.assertTrue(test_record.phone_blacklisted)
+
+            bl_record_2 = self.env['phone.blacklist'].sudo().create([{'number': self.test_numbers_san[1]}])
+            self.assertEqual(bl_record, bl_record_2)
+
+            rec = self.env['mail.test.sms.bl'].search([('phone_blacklisted', '=', True)])
+            self.assertEqual(rec, test_record)
+
+            bl_record.unlink()
+            rec = self.env['mail.test.sms.bl'].search([('phone_blacklisted', '=', True)])
+            self.assertEqual(rec, self.env['mail.test.sms.bl'])
+
+    def test_phone_sanitize_api(self):
+        with self.sudo('employee'):
+            test_record = self.env['mail.test.sms.bl'].browse(self.test_record.id)
+            self.assertFalse(test_record.phone_blacklisted)
+
+            test_record._phone_set_blacklisted()
+            test_record.invalidate_cache()
+            self.assertTrue(test_record.phone_blacklisted)
+
+            test_record._phone_reset_blacklisted()
+            test_record.invalidate_cache()
+            self.assertFalse(test_record.phone_blacklisted)
+
+    def test_phone_sanitize_internals(self):
+        with self.sudo('employee'):
+            test_record = self.env['mail.test.sms.bl'].browse(self.test_record.id)
+            self.assertEqual(test_record.phone_nbr, self.test_numbers[1])
+            self.assertEqual(test_record.phone_sanitized, self.test_numbers_san[1])
+
+            test_record.write({'phone_nbr': 'incorrect'})
+            self.assertEqual(test_record.phone_nbr, 'incorrect')
+            self.assertEqual(test_record.phone_sanitized, self.test_numbers_san[0])
+
+            test_record.write({'mobile_nbr': 'incorrect'})
+            self.assertEqual(test_record.mobile_nbr, 'incorrect')
+            self.assertEqual(test_record.phone_sanitized, False)
+
+            test_record.write({'phone_nbr': self.test_numbers[1]})
+            self.assertEqual(test_record.phone_nbr, self.test_numbers[1])
+            self.assertEqual(test_record.phone_sanitized, self.test_numbers_san[1])

addons/test_mail_full/tests/test_sms_composer.py

@@ -1,13 +1,11 @@
 # -*- coding: utf-8 -*-
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 
-from odoo.addons.phone_validation.tools import phone_validation
 from odoo.addons.sms.tests import common as sms_common
-from odoo.addons.test_mail.tests import common as test_mail_common
 from odoo.addons.test_mail_full.tests import common as test_mail_full_common
 
 
-class TestSMSComposerComment(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_common.MockEmails, test_mail_common.TestRecipients):
+class TestSMSComposerComment(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_full_common.TestRecipients):
     """ TODO LIST
 
      * add test for default_res_model / default_res_id and stuff like that;
@@ -21,11 +19,6 @@ class TestSMSComposerComment(test_mail_full_common.BaseFunctionalTest, sms_commo
         super(TestSMSComposerComment, cls).setUpClass()
         cls._test_body = 'VOID CONTENT'
 
-        cls.partner_numbers = [
-            phone_validation.phone_format(partner.mobile, partner.country_id.code, partner.country_id.phone_code, force_format='E164')
-            for partner in (cls.partner_1 | cls.partner_2)
-        ]
-
         cls.test_record = cls.env['mail.test.sms'].with_context(**cls._test_context).create({
             'name': 'Test',
             'customer_id': cls.partner_1.id,
@@ -159,7 +152,7 @@ class TestSMSComposerComment(test_mail_full_common.BaseFunctionalTest, sms_commo
     #     self.assertSMSSent((self.partner_1 | self.partner_2).mapped('mobile'), test_body)
 
 
-class TestSMSComposerMass(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_common.MockEmails, test_mail_common.TestRecipients):
+class TestSMSComposerMass(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS):
     """ TODO LIST
 
     * add test for mass with log note
@@ -170,28 +163,8 @@ class TestSMSComposerMass(test_mail_full_common.BaseFunctionalTest, sms_common.M
         super(TestSMSComposerMass, cls).setUpClass()
         cls._test_body = 'Zizisse an SMS.'
 
-        records = cls.env['mail.test.sms']
-        partners = cls.env['res.partner']
-        country_id = cls.env.ref('base.be').id,
-        for x in range(3):
-            partners += cls.env['res.partner'].with_context(**cls._test_context).create({
-                'name': 'Partner_%s' % (x),
-                'email': '_test_partner_%s@example.com' % (x),
-                'country_id': country_id,
-                'mobile': '047500%s%s99' % (x, x)
-            })
-            records += cls.env['mail.test.sms'].with_context(**cls._test_context).create({
-                'name': 'Test_%s' % (x),
-                'customer_id': partners[x].id,
-            })
-        cls.records = cls._reset_mail_context(records)
-        cls.partners = partners
-
-        cls.sms_template = cls.env['sms.template'].create({
-            'name': 'Test Template',
-            'model_id': cls.env['ir.model']._get('mail.test.sms').id,
-            'body': 'Dear ${object.display_name} this is an SMS.',
-        })
+        cls._create_records_for_batch('mail.test.sms', 3)
+        cls.sms_template = cls._create_sms_template('mail.test.sms')
 
     def test_composer_mass_active_domain(self):
         with self.sudo('employee'):
@@ -291,35 +264,3 @@ class TestSMSComposerMass(test_mail_full_common.BaseFunctionalTest, sms_common.M
                 self.assertSMSOutgoing(record.customer_id, None, 'Cher·e· %s ceci est un SMS.' % record.display_name)
             else:
                 self.assertSMSOutgoing(record.customer_id, None, 'Dear %s this is an SMS.' % record.display_name)
-
-    def test_message_schedule_sms(self):
-        with self.sudo('employee'):
-            with self.mockSMSGateway():
-                self.env['mail.test.sms'].browse(self.records.ids)._message_sms_schedule_mass(body=self._test_body)
-
-        for record in self.records:
-            self.assertSMSOutgoing(record.customer_id, None, self._test_body)
-
-    def test_message_schedule_sms_w_log(self):
-        with self.sudo('employee'):
-            with self.mockSMSGateway():
-                self.env['mail.test.sms'].browse(self.records.ids)._message_sms_schedule_mass(body=self._test_body, mass_keep_log=True)
-
-        for record in self.records:
-            self.assertSMSNotification([{'partner': record.customer_id, 'state': 'ready'}], self._test_body)
-
-    def test_message_schedule_sms_w_template(self):
-        with self.sudo('employee'):
-            with self.mockSMSGateway():
-                self.env['mail.test.sms'].browse(self.records.ids)._message_sms_schedule_mass(template=self.sms_template)
-
-        for record in self.records:
-            self.assertSMSOutgoing(record.customer_id, None, 'Dear %s this is an SMS.' % record.display_name)
-
-    def test_message_schedule_sms_w_template_and_log(self):
-        with self.sudo('employee'):
-            with self.mockSMSGateway():
-                self.env['mail.test.sms'].browse(self.records.ids)._message_sms_schedule_mass(template=self.sms_template, mass_keep_log=True)
-
-        for record in self.records:
-            self.assertSMSNotification([{'partner': record.customer_id, 'state': 'ready'}], 'Dear %s this is an SMS.' % record.display_name)

addons/test_mail_full/tests/test_sms_management.py

@@ -2,11 +2,10 @@
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 
 from odoo.addons.sms.tests import common as sms_common
-from odoo.addons.test_mail.tests import common as test_mail_common
 from odoo.addons.test_mail_full.tests import common as test_mail_full_common
 
 
-class TestSMSWizards(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_common.MockEmails, test_mail_common.TestRecipients):
+class TestSMSWizards(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_full_common.TestRecipients):
 
     @classmethod
     def setUpClass(cls):

addons/test_mail_full/tests/test_sms_post.py

@@ -1,13 +1,11 @@
 # -*- coding: utf-8 -*-
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 
-from odoo.addons.phone_validation.tools import phone_validation
 from odoo.addons.sms.tests import common as sms_common
-from odoo.addons.test_mail.tests import common as test_mail_common
 from odoo.addons.test_mail_full.tests import common as test_mail_full_common
 
 
-class TestSMSPost(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_common.MockEmails, test_mail_common.TestRecipients):
+class TestSMSPost(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_full_common.TestRecipients):
     """ TODO
 
       * add tests for new mail.message and mail.thread fields;
@@ -18,11 +16,6 @@ class TestSMSPost(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS,
         super(TestSMSPost, cls).setUpClass()
         cls._test_body = 'VOID CONTENT'
 
-        cls.partner_numbers = [
-            phone_validation.phone_format(partner.mobile, partner.country_id.code, partner.country_id.phone_code, force_format='E164')
-            for partner in (cls.partner_1 | cls.partner_2)
-        ]
-
         cls.test_record = cls.env['mail.test.sms'].with_context(**cls._test_context).create({
             'name': 'Test',
             'customer_id': cls.partner_1.id,
@@ -227,7 +220,7 @@ class TestSMSPost(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS,
         self.assertSMSNotification([{'partner': self.partner_1, 'number': self.test_numbers_san[1]}], 'Dear %s this is an SMS.' % self.test_record.display_name, messages)
 
 
-class TestSMSPostException(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_common.MockEmails, test_mail_common.TestRecipients):
+class TestSMSPostException(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_full_common.TestRecipients):
 
     @classmethod
     def setUpClass(cls):
@@ -304,7 +297,7 @@ class TestSMSPostException(test_mail_full_common.BaseFunctionalTest, sms_common.
         ], self._test_body, messages)
 
     def test_message_sms_crash_credit_single(self):
-        with self.sudo('employee'), self.mockSMSGateway(nbr_t_error={phone_validation.phone_get_sanitized_record_number(self.partner_2): 'credit'}):
+        with self.sudo('employee'), self.mockSMSGateway(nbr_t_error={self.partner_2.phone_get_sanitized_number(): 'credit'}):
             test_record = self.env['mail.test.sms'].browse(self.test_record.id)
             messages = test_record._message_sms(self._test_body, partner_ids=(self.partner_1 | self.partner_2 | self.partner_3).ids)
 
@@ -336,7 +329,7 @@ class TestSMSPostException(test_mail_full_common.BaseFunctionalTest, sms_common.
         ], self._test_body, messages)
 
     def test_message_sms_crash_wrong_number_single(self):
-        with self.sudo('employee'), self.mockSMSGateway(nbr_t_error={phone_validation.phone_get_sanitized_record_number(self.partner_2): 'wrong_number_format'}):
+        with self.sudo('employee'), self.mockSMSGateway(nbr_t_error={self.partner_2.phone_get_sanitized_number(): 'wrong_number_format'}):
             test_record = self.env['mail.test.sms'].browse(self.test_record.id)
             messages = test_record._message_sms(self._test_body, partner_ids=(self.partner_1 | self.partner_2 | self.partner_3).ids)
 
@@ -345,3 +338,46 @@ class TestSMSPostException(test_mail_full_common.BaseFunctionalTest, sms_common.
             {'partner': self.partner_2, 'state': 'exception', 'failure_type': 'sms_number_format'},
             {'partner': self.partner_3, 'state': 'sent'},
         ], self._test_body, messages)
+
+
+class TestSMSApi(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestSMSApi, cls).setUpClass()
+        cls._test_body = 'Zizisse an SMS.'
+
+        cls._create_records_for_batch('mail.test.sms', 3)
+        cls.sms_template = cls._create_sms_template('mail.test.sms')
+
+    def test_message_schedule_sms(self):
+        with self.sudo('employee'):
+            with self.mockSMSGateway():
+                self.env['mail.test.sms'].browse(self.records.ids)._message_sms_schedule_mass(body=self._test_body)
+
+        for record in self.records:
+            self.assertSMSOutgoing(record.customer_id, None, self._test_body)
+
+    def test_message_schedule_sms_w_log(self):
+        with self.sudo('employee'):
+            with self.mockSMSGateway():
+                self.env['mail.test.sms'].browse(self.records.ids)._message_sms_schedule_mass(body=self._test_body, mass_keep_log=True)
+
+        for record in self.records:
+            self.assertSMSNotification([{'partner': record.customer_id, 'state': 'ready'}], self._test_body)
+
+    def test_message_schedule_sms_w_template(self):
+        with self.sudo('employee'):
+            with self.mockSMSGateway():
+                self.env['mail.test.sms'].browse(self.records.ids)._message_sms_schedule_mass(template=self.sms_template)
+
+        for record in self.records:
+            self.assertSMSOutgoing(record.customer_id, None, 'Dear %s this is an SMS.' % record.display_name)
+
+    def test_message_schedule_sms_w_template_and_log(self):
+        with self.sudo('employee'):
+            with self.mockSMSGateway():
+                self.env['mail.test.sms'].browse(self.records.ids)._message_sms_schedule_mass(template=self.sms_template, mass_keep_log=True)
+
+        for record in self.records:
+            self.assertSMSNotification([{'partner': record.customer_id, 'state': 'ready'}], 'Dear %s this is an SMS.' % record.display_name)

addons/test_mail_full/tests/test_sms_server_actions.py

@@ -2,15 +2,14 @@
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 
 from odoo.addons.sms.tests import common as sms_common
-from odoo.addons.test_mail.tests import common as test_mail_common
 from odoo.addons.test_mail_full.tests import common as test_mail_full_common
 
 
-class TestSmsTemplate(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_common.TestRecipients):
+class TestServerAction(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_full_common.TestRecipients):
 
     @classmethod
     def setUpClass(cls):
-        super(TestSmsTemplate, cls).setUpClass()
+        super(TestServerAction, cls).setUpClass()
         cls.test_record = cls.env['mail.test.sms'].with_context(**cls._test_context).create({
             'name': 'Test',
             'customer_id': cls.partner_1.id,
@@ -21,16 +20,10 @@ class TestSmsTemplate(test_mail_full_common.BaseFunctionalTest, sms_common.MockS
             'phone_nbr': cls.test_numbers[0],
         })
 
-        model_id = cls.env['ir.model']._get('mail.test.sms').id
-        cls.sms_template = cls.env['sms.template'].create({
-            'name': 'Test Template',
-            'model_id': model_id,
-            'body': 'Dear ${object.display_name} this is an SMS.'
-        })
-
+        cls.sms_template = cls._create_sms_template('mail.test.sms')
         cls.action = cls.env['ir.actions.server'].create({
             'name': 'Test SMS Action',
-            'model_id': model_id,
+            'model_id': cls.env['ir.model']._get('mail.test.sms').id,
             'state': 'sms',
             'sms_template_id': cls.sms_template.id,
         })

addons/test_mail_full/tests/test_sms_sms.py

@@ -7,11 +7,10 @@ from unittest.mock import DEFAULT
 from odoo import exceptions
 from odoo.addons.sms.models.sms_sms import SmsSms as SmsSms
 from odoo.addons.sms.tests import common as sms_common
-from odoo.addons.test_mail.tests import common as test_mail_common
 from odoo.addons.test_mail_full.tests import common as test_mail_full_common
 
 
-class TestSMSPost(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_common.MockEmails, test_mail_common.TestRecipients):
+class TestSMSPost(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS):
 
     @classmethod
     def setUpClass(cls):

addons/test_mail_full/tests/test_sms_template.py

@@ -2,11 +2,10 @@
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 
 from odoo.addons.sms.tests import common as sms_common
-from odoo.addons.test_mail.tests import common as test_mail_common
 from odoo.addons.test_mail_full.tests import common as test_mail_full_common
 
 
-class TestSmsTemplate(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_common.MockEmails, test_mail_common.TestRecipients):
+class TestSmsTemplate(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_full_common.TestRecipients):
 
     @classmethod
     def setUpClass(cls):
@@ -19,11 +18,7 @@ class TestSmsTemplate(test_mail_full_common.BaseFunctionalTest, sms_common.MockS
 
         cls.body_en = 'Dear ${object.display_name} this is an SMS.'
         cls.body_fr = u"Hello ${object.display_name} ceci est en français."
-        cls.sms_template = cls.env['sms.template'].create({
-            'name': 'Test Template',
-            'model_id': cls.env['ir.model']._get('mail.test.sms').id,
-            'body': cls.body_en,
-        })
+        cls.sms_template = cls._create_sms_template('mail.test.sms', body=cls.body_en)
 
     def test_sms_template_render(self):
         rendered_body = self.sms_template._render_template(self.sms_template.body, self.sms_template.model, self.test_record.ids)