Support CharField for Django parity and correct Form fields (#74)

* * Added support for different keys based on database (#67)

* Updated tests to include digest and hash

* Completed #73

* Adds additional tests to #73

* Code clean up

* Merged in master

* Added 2nd db to travis (it doesn't fail but this is more precise)

Author: peterfarrell

.travis.yml

@@ -12,6 +12,7 @@ services:
   - postgresql
 before_script:
   - psql -c 'CREATE DATABASE pgcrypto_fields' -U postgres
+  - psql -c 'CREATE DATABASE pgcrypto_fields_diff' -U postgres
 install:
   - pip install -e .
   - pip install -r requirements_dev.txt

README.md

@@ -147,6 +147,7 @@ the data and also changing the hash to match.
 #### Public Key Encryption Fields
 
 Supported PGP public key fields are:
+ - `CharPGPPublicKeyField`
  - `EmailPGPPublicKeyField`
  - `IntegerPGPPublicKeyField`
  - `TextPGPPublicKeyField`
@@ -165,6 +166,7 @@ Public and private keys can be set in settings with `PUBLIC_PGP_KEY` and
 #### Symmetric Key Encryption Fields
 
 Supported PGP symmetric key fields are:
+ - `CharPGPSymmetricKeyField`
  - `EmailPGPSymmetricKeyField`
  - `IntegerPGPSymmetricKeyField`
  - `TextPGPSymmetricKeyField`

pgcrypto/fields.py

@@ -15,7 +15,6 @@
     HashMixin,
     PGPPublicKeyFieldMixin,
     PGPSymmetricKeyFieldMixin,
-    RemoveMaxLengthValidatorMixin,
 )
 
 
@@ -39,8 +38,7 @@ class TextHMACField(HashMixin, models.TextField):
 TextHMACField.register_lookup(HashLookup)
 
 
-class EmailPGPPublicKeyField(RemoveMaxLengthValidatorMixin,
-                             PGPSymmetricKeyFieldMixin, models.EmailField):
+class EmailPGPPublicKeyField(PGPSymmetricKeyFieldMixin, models.EmailField):
     """Email PGP public key encrypted field."""
 
 
@@ -54,6 +52,10 @@ class TextPGPPublicKeyField(PGPPublicKeyFieldMixin, models.TextField):
     """Text PGP public key encrypted field."""
 
 
+class CharPGPPublicKeyField(PGPPublicKeyFieldMixin, models.CharField):
+    """Char PGP public key encrypted field."""
+
+
 class DatePGPPublicKeyField(PGPPublicKeyFieldMixin, models.DateField):
     """Date PGP public key encrypted field for postgres."""
     encrypt_sql = PGP_PUB_ENCRYPT_SQL_WITH_NULLIF
@@ -66,8 +68,7 @@ class DateTimePGPPublicKeyField(PGPPublicKeyFieldMixin, models.DateTimeField):
     cast_type = 'TIMESTAMP'
 
 
-class EmailPGPSymmetricKeyField(RemoveMaxLengthValidatorMixin,
-                                PGPSymmetricKeyFieldMixin, models.EmailField):
+class EmailPGPSymmetricKeyField(PGPSymmetricKeyFieldMixin, models.EmailField):
     """Email PGP symmetric key encrypted field."""
 
 
@@ -81,6 +82,10 @@ class TextPGPSymmetricKeyField(PGPSymmetricKeyFieldMixin, models.TextField):
     """Text PGP symmetric key encrypted field for postgres."""
 
 
+class CharPGPSymmetricKeyField(PGPSymmetricKeyFieldMixin, models.CharField):
+    """Char PGP symmetric key encrypted field for postgres."""
+
+
 class DatePGPSymmetricKeyField(PGPSymmetricKeyFieldMixin, models.DateField):
     """Date PGP symmetric key encrypted field for postgres."""
     encrypt_sql = PGP_SYM_ENCRYPT_SQL_WITH_NULLIF

pgcrypto/mixins.py

@@ -91,7 +91,6 @@ class PGPMixin:
 
     def __init__(self, *args, **kwargs):
         """`max_length` should be set to None as encrypted text size is variable."""
-        kwargs['max_length'] = None
         super().__init__(*args, **kwargs)
 
     def db_type(self, connection=None):
@@ -110,10 +109,6 @@ def get_decrypt_sql(self, connection):
         """Get decrypt sql."""
         raise NotImplementedError('The `get_decrypt_sql` needs to be implemented.')
 
-    def _check_max_length_attribute(self, **kwargs):
-        """Override `_check_max_length_attribute` to remove check on max_length."""
-        return []
-
     def get_col(self, alias, output_field=None):
         """Get the decryption for col."""
         if output_field is None:

tests/diff_keys/models.py

@@ -4,8 +4,14 @@
 
 
 class EncryptedDiff(models.Model):
-    pub_field = fields.TextPGPPublicKeyField()
-    sym_field = fields.TextPGPSymmetricKeyField()
+    CHOICES = (
+        ('a', 'a'),
+        (1, '1'),
+    )
+    pub_field = fields.CharPGPPublicKeyField(blank=True, null=True,
+                                             choices=CHOICES, max_length=1)
+    sym_field = fields.CharPGPSymmetricKeyField(blank=True, null=True,
+                                                choices=CHOICES, max_length=1)
     digest_field = fields.TextDigestField(blank=True, null=True)
     hmac_field = fields.TextHMACField(blank=True, null=True)
 

tests/factories.py

@@ -24,6 +24,7 @@ class EncryptedModelFactory(factory.DjangoModelFactory):
     email_pgp_pub_field = factory.Sequence('email{}@public.key'.format)
     integer_pgp_pub_field = 42
     pgp_pub_field = factory.Sequence('Text with public key {}'.format)
+    char_pub_field = factory.Sequence('Text {}'.format)
 
     date_pgp_pub_field = date.today()
     datetime_pgp_pub_field = datetime.now()
@@ -32,6 +33,7 @@ class EncryptedModelFactory(factory.DjangoModelFactory):
     email_pgp_sym_field = factory.Sequence('email{}@symmetric.key'.format)
     integer_pgp_sym_field = 43
     pgp_sym_field = factory.Sequence('Text with symmetric key {}'.format)
+    char_sym_field = factory.Sequence('Text {}'.format)
 
     date_pgp_sym_field = date.today()
     datetime_pgp_sym_field = datetime.now()

tests/models.py

@@ -32,6 +32,7 @@ class EncryptedModel(models.Model):
                                                         unique=True)
     integer_pgp_pub_field = fields.IntegerPGPPublicKeyField(blank=True, null=True)
     pgp_pub_field = fields.TextPGPPublicKeyField(blank=True, null=True)
+    char_pub_field = fields.CharPGPPublicKeyField(blank=True, null=True, max_length=15)
     date_pgp_pub_field = fields.DatePGPPublicKeyField(blank=True, null=True)
     datetime_pgp_pub_field = fields.DateTimePGPPublicKeyField(blank=True, null=True)
     time_pgp_pub_field = fields.TimePGPPublicKeyField(blank=True, null=True)
@@ -43,6 +44,7 @@ class EncryptedModel(models.Model):
     email_pgp_sym_field = fields.EmailPGPSymmetricKeyField(blank=True, null=True)
     integer_pgp_sym_field = fields.IntegerPGPSymmetricKeyField(blank=True, null=True)
     pgp_sym_field = fields.TextPGPSymmetricKeyField(blank=True, null=True)
+    char_sym_field = fields.CharPGPPublicKeyField(blank=True, null=True, max_length=15)
     date_pgp_sym_field = fields.DatePGPSymmetricKeyField(blank=True, null=True)
     datetime_pgp_sym_field = fields.DateTimePGPSymmetricKeyField(blank=True, null=True)
     time_pgp_sym_field = fields.TimePGPSymmetricKeyField(blank=True, null=True)

tests/test_fields.py

@@ -47,12 +47,6 @@ def test_check(self):
                 field.model = MagicMock()
                 self.assertEqual(field(name='field').check(), [])
 
-    def test_max_length(self):
-        """Assert `max_length` is ignored."""
-        for field in PGP_FIELDS:
-            with self.subTest(field=field):
-                self.assertEqual(field(max_length=42).max_length, None)
-
     def test_db_type(self):
         """Check db_type is `bytea`."""
         for field in PGP_FIELDS:
@@ -90,10 +84,12 @@ def test_fields(self):
             'email_pgp_pub_field',
             'integer_pgp_pub_field',
             'pgp_pub_field',
+            'char_pub_field',
             'decimal_pgp_pub_field',
             'email_pgp_sym_field',
             'integer_pgp_sym_field',
             'pgp_sym_field',
+            'char_sym_field',
             'date_pgp_sym_field',
             'datetime_pgp_sym_field',
             'time_pgp_sym_field',
@@ -456,6 +452,50 @@ def test_pgp_public_key_time_form(self):
             expected
         )
 
+    def test_pgp_public_key_char_field(self):
+        """Test public key CharField."""
+        expect = 'Peter'
+        EncryptedModelFactory.create(char_pub_field=expect)
+
+        instance = EncryptedModel.objects.get()
+
+        self.assertTrue(
+            instance.char_pub_field,
+            expect
+        )
+
+        payload = {
+            'char_pub_field': 'This is beyond 15 max length'
+        }
+
+        form = EncryptedForm(payload, instance=instance)
+        is_valid = form.is_valid()
+        errors = form.errors.as_data()
+        self.assertFalse(is_valid)
+        self.assertTrue(1, len(errors['char_pub_field']))
+
+    def test_pgp_symmetric_key_char_field(self):
+        """Test symmetric key CharField."""
+        expect = 'Peter'
+        EncryptedModelFactory.create(char_sym_field=expect)
+
+        instance = EncryptedModel.objects.get()
+
+        self.assertTrue(
+            instance.char_sym_field,
+            expect
+        )
+
+        payload = {
+            'char_sym_field': 'This is beyond 15 max length'
+        }
+
+        form = EncryptedForm(payload, instance=instance)
+        is_valid = form.is_valid()
+        errors = form.errors.as_data()
+        self.assertFalse(is_valid)
+        self.assertTrue(1, len(errors['char_sym_field']))
+
     def test_pgp_symmetric_key_date_lookups(self):
         """Assert lookups `DatePGPSymmetricKeyField` field."""
         EncryptedModelFactory.create(date_pgp_sym_field=date(2016, 7, 1))
@@ -1304,19 +1344,35 @@ def test_get_col(self):
 
         RelatedDateTime.objects.create(related=related, related_again=related_again)
 
-        instance = RelatedDateTime.objects.select_related(
-            'related', 'related_again'
-        )
-
         instance = RelatedDateTime.objects.select_related(
             'related', 'related_again'
         ).get()
 
         self.assertIsInstance(instance, RelatedDateTime)
 
+    def test_char_field_choices(self):
+        """Test CharField choices."""
+        expected = 1
+        instance = EncryptedDiff.objects.create(
+            pub_field=expected,
+            sym_field=expected,
+        )
+        instance.refresh_from_db()
+
+        # choices always come back as strings
+        self.assertTrue(
+            '{}'.format(expected),
+            instance.pub_field
+        )
+
+        self.assertTrue(
+            '{}'.format(expected),
+            instance.sym_field
+        )
+
     def test_write_to_diff_keys(self):
         """Test writing to diff_keys db which uses different keys."""
-        expected = 'bonjour'
+        expected = 'a'
         instance = EncryptedDiff.objects.create(
             pub_field=expected,
             sym_field=expected,
@@ -1325,7 +1381,7 @@ def test_write_to_diff_keys(self):
         )
 
         reset_queries()  # Required for Django 1.11
-        instance = EncryptedDiff.objects.get(id=1)
+        instance = EncryptedDiff.objects.get()
 
         self.assertTrue(
             instance.pub_field,