Custom validator not working running tests

I have two models which have one common field but in a different context.

models.py:

import uuid

from django.core.validators import (EmailValidator, MaxLengthValidator,
                                    MaxValueValidator, MinLengthValidator,


                      MinValueValidator,)
from django.db import models
from django.utils import timezone

from .validators import (validar_cep, validar_ddd,
                         validar_numero_telefone, validar_uf,)

class Endereco(ModeloComum):
    bairro = models.CharField(max_length=255)
    cep = models.CharField(
        error_messages={
            'max_length': 'CEP inválido. O CEP deve conter uma entrada com 8 '
                          'digitos numéricos.',
        },
        max_length=8,
        validators=[validar_cep],
    )
    cidade = models.CharField(max_length=255)
    complemento = models.CharField(blank=True, max_length=32, null=True,)
    logradouro = models.CharField(max_length=255)
    numero = models.PositiveIntegerField(
        error_messages={
            'invalid': 'Insira um número válido. A entrada "%(value)s" não é '
                       'um valor inteiro positivo.',
        }
    )
    pessoa = models.ForeignKey(
        'Pessoa',
        models.PROTECT,
        related_name='enderecos',
        related_query_name='endereco',
    )
    uf = models.CharField(
        error_messages={
            'max_length': 'UF inválido. UF deve conter somente 2 caracteres '
                          'em letras maiúsculas',
        },
        max_length=2,
        validators=[validar_uf],
    )

    class Meta:
        ordering = ('uf', 'cidade', 'bairro', 'cep', 'numero', )
        verbose_name = 'Endereco'
        verbose_name_plural = 'Enderecos'

    def __str__(self):
         return '[%s - %s, %s/%s]' % (
             self.cep,
             self.bairro,
             self.cidade,
             self.uf
         )
class SeguroAuto(ModeloComum):
     cep_pernoite = models.CharField(
        error_messages={
            'max_length': 'CEP inválido. O CEP deve conter uma entrada com 8 '
                          'digitos numéricos.',
        },
        max_length=8,
        validators=[validar_cep],
    )
    cep_maior_frequencia = models.CharField(
        error_messages={
            'max_length': 'CEP inválido. O CEP deve conter uma entrada com 8 '
                          'digitos numéricos.',
        },
        max_length=8,
        validators=[validar_cep],
    )
    quilometragem_media = models.CharField(
        choices=QUILOMETRAGEM_MEDIA,
        default='Até 500 km/mês',
        error_messages={
            'invalid_choice': 'Selecione uma opção válida. "%(value)s" não é '
                              'uma das opções disponíveis.'
        },
        max_length=14,
    )

    class Meta:
        ordering = ('segurado', 'uuid', )
        verbose_name = 'SeguroAuto'
        verbose_name_plural = 'SegurosAuto'

    def __str__(self):
        try:
            return '[%s - %s | %s]' % (
                self.segurado.pessoa.nome,
                self.segurado.pessoa.cpf,
                self.uuid
            )
        except Exception:
            return '[%s]' % (self.uuid)

I need to validate this fields, so I created a file validators.py, which are called in models.py (validators=[validar_cep]) as above:

validators.py:

import re

# from django.core.exceptions import ValidationError
from django.core.validators import RegexValidator

from .utils.regex import Regex

# ------- Mensagens -------
CEP_INVALIDO = (
    'CEP inválido. O CEP deve conter uma entrada com 8 digitos numéricos.'
)
# ------- Regex -------
CEP = re.compile(r'^[0-9]$')

# ------- Validation Functions -------


def validar_cep(valor):
    validador = RegexValidator(
        regex=CEP,
        message=CEP_INVALIDO,
        code='invalid'
    )
    validador(valor)

Finally, I have the test file to test if I persist an invalid value is showing the correct message:

test_seguro_auto.py

from itertools import cycle

from django.core.exceptions import ValidationError
from django.test import TestCase
from model_mommy import mommy

from saldanprev.core.models import Segurado, SeguroAuto


class TestSeguroAuto(TestCase):
    """
    Teste do modelo SeguroAuto
    """
    def setUp(self):
        self.cep_pernoite = '05271260'
        self.cep_maior_frequencia = '05133001'
        self.quilometragem_media = 'Até 500 km/mês'
        self.seguro_auto = mommy.make(
            SeguroAuto,
            cep_pernoite=self.cep_pernoite,
            cep_maior_frequencia=self.cep_maior_frequencia,
            quilometragem_media=self.quilometragem_media,
        )

    def teste_cep_pernoite_invalido(self):

        """
        Verifica a mensagem de erro do atributo cep_pernoite caso seja
            persistido uma entrada de cep de pernoite inválida.
        """
        mensagem = (
            'CEP inválido. O CEP deve conter uma entrada com 8 digitos '
            'numéricos.'
        )

        with self.assertRaisesMessage(ValidationError, mensagem):
            mommy.make(SeguroAuto, cep_pernoite='010010-01')

        with self.assertRaisesMessage(ValidationError, mensagem):
            mommy.make(SeguroAuto, cep_pernoite='010010001')

        with self.assertRaisesMessage(ValidationError, mensagem):
           mommy.make(SeguroAuto, cep_pernoite='0100100')

If I run just this test, it passes. But if I run all my tests, all of them broke and the following message is showed off:

self = <SeguroAuto: [010ec070-5b6e-4c3a-8368-8bb674bfada5]>, exclude = ['cep_pernoite'], validate_unique = True

    def full_clean(self, exclude=None, validate_unique=True):
        """
            Call clean_fields(), clean(), and validate_unique() on the model.
            Raise a ValidationError for any errors that occur.
            """
        errors = {}
        if exclude is None:
            exclude = []
        else:
            exclude = list(exclude)

        try:
            self.clean_fields(exclude=exclude)
        except ValidationError as e:
            errors = e.update_error_dict(errors)

        # Form.clean() is run even if other validation fails, so do the
        # same with Model.clean() for consistency.
        try:
            self.clean()
        except ValidationError as e:
            errors = e.update_error_dict(errors)

        # Run unique checks, but only for fields that passed validation.
        if validate_unique:
            for name in errors:
                if name != NON_FIELD_ERRORS and name not in exclude:
                    exclude.append(name)
            try:
                self.validate_unique(exclude=exclude)
            except ValidationError as e:
                errors = e.update_error_dict(errors)

        if errors:
>           raise ValidationError(errors)
E           django.core.exceptions.ValidationError: {'cep_pernoite': ['CEP inválido. O CEP deve conter uma entrada com 8 digitos numéricos.']}

/usr/local/lib/python3.6/site-packages/django/db/models/base.py:1166: ValidationError 

I tried to search for it is happening but I did not find any good information that can help me to solve it. I need to validate this fields but has not been possible using a custom validator.

Perhaps, should be something related to validate_unique(), but I cannot know why is it. It is just a hunch!

What could be? Is there another efficient way to do it?

PS: In models.py, I omitted my other models, because I think that they are not in relation to this problem.