Code review fixes (2/x)

- Add missing fields

Author: aclark4life

tests/encryption_/models.py

@@ -1,16 +1,21 @@
 from django.db import models
 
 from django_mongodb_backend.fields import (
+    EncryptedBigIntegerField,
     EncryptedBinaryField,
     EncryptedBooleanField,
     EncryptedCharField,
     EncryptedDateField,
     EncryptedDateTimeField,
     EncryptedDecimalField,
+    EncryptedDurationField,
     EncryptedEmailField,
     EncryptedFloatField,
     EncryptedGenericIPAddressField,
     EncryptedIntegerField,
+    EncryptedPositiveBigIntegerField,
+    EncryptedPositiveIntegerField,
+    EncryptedPositiveSmallIntegerField,
     EncryptedSmallIntegerField,
     EncryptedTextField,
     EncryptedTimeField,
@@ -28,41 +33,48 @@ class Meta:
 
 
 class Appointment(QueryableEncryptionModelBase):
-    time = EncryptedTimeField(queries=EQUALITY_QUERY)
+    start_time = EncryptedTimeField(queries=EQUALITY_QUERY)
 
 
 class Billing(QueryableEncryptionModelBase):
     account_balance = EncryptedDecimalField(max_digits=10, decimal_places=2, queries=RANGE_QUERY)
+    payment_duration = EncryptedDurationField(queries=RANGE_QUERY)  # Duration for billing period
 
 
 class CreditCard(QueryableEncryptionModelBase):
-    cc_type = EncryptedCharField(max_length=20, queries=EQUALITY_QUERY)
-    cc_number = EncryptedIntegerField(queries=EQUALITY_QUERY)
+    card_type = EncryptedCharField(max_length=20, queries=EQUALITY_QUERY)
+    card_number = EncryptedIntegerField(queries=EQUALITY_QUERY)
+    transaction_reference = EncryptedBigIntegerField(
+        queries=EQUALITY_QUERY
+    )  # Simulating a long transaction ID
 
 
 class PatientPortalUser(QueryableEncryptionModelBase):
-    ip_address = EncryptedGenericIPAddressField(queries=EQUALITY_QUERY)
-    url = EncryptedURLField(queries=EQUALITY_QUERY)
+    last_login_ip = EncryptedGenericIPAddressField(queries=EQUALITY_QUERY)
+    profile_url = EncryptedURLField(queries=EQUALITY_QUERY)
 
 
 class PatientRecord(QueryableEncryptionModelBase):
     ssn = EncryptedCharField(max_length=11, queries=EQUALITY_QUERY)
     birth_date = EncryptedDateField(queries=RANGE_QUERY)
-    profile_picture = EncryptedBinaryField(queries=EQUALITY_QUERY)
-    patient_age = EncryptedSmallIntegerField(queries={**RANGE_QUERY, "min": 0, "max": 100})
+    profile_picture_data = EncryptedBinaryField(queries=EQUALITY_QUERY)
+    age = EncryptedSmallIntegerField(queries={**RANGE_QUERY, "min": 0, "max": 100})
     weight = EncryptedFloatField(queries=RANGE_QUERY)
+    insurance_policy_number = EncryptedPositiveBigIntegerField(queries=EQUALITY_QUERY)
+    emergency_contacts_count = EncryptedPositiveIntegerField(queries=EQUALITY_QUERY)
+    completed_visits = EncryptedPositiveSmallIntegerField(queries=EQUALITY_QUERY)
 
     # TODO: Embed Billing model
     # billing = EncryptedEmbeddedField(Billing)
 
 
 class Patient(QueryableEncryptionModelBase):
     patient_id = EncryptedIntegerField(queries=EQUALITY_QUERY)
-    patient_name = EncryptedCharField(max_length=100)
-    patient_notes = EncryptedTextField(queries=EQUALITY_QUERY)
+    full_name = EncryptedCharField(max_length=100)
+    notes = EncryptedTextField(queries=EQUALITY_QUERY)
     registration_date = EncryptedDateTimeField(queries=EQUALITY_QUERY)
     is_active = EncryptedBooleanField(queries=EQUALITY_QUERY)
-    email = EncryptedEmailField(queries=EQUALITY_QUERY)
+    contact_email = EncryptedEmailField(queries=EQUALITY_QUERY)
 
     # TODO: Embed PatientRecord model
     # patient_record = EncryptedEmbeddedField(PatientRecord)

tests/encryption_/test_fields.py

@@ -1,4 +1,4 @@
-from datetime import date, datetime, time
+from datetime import date, datetime, time, timedelta
 
 import pymongo
 from bson.binary import Binary
@@ -20,31 +20,47 @@ class FieldTests(QueryableEncryptionTestCase):
     def setUp(self):
         Patient.objects.create(
             patient_id=1,
-            patient_name="John Doe",
-            patient_notes="patient notes " * 25,
+            full_name="John Doe",
+            notes="patient notes " * 25,
             registration_date=datetime(2023, 10, 1, 12, 0, 0),
             is_active=True,
-            email="[email protected]",
+            contact_email="[email protected]",
         )
         PatientRecord.objects.create(
             ssn="123-45-6789",
             birth_date="1969-01-01",
-            profile_picture=b"image data",
-            patient_age=50,
+            profile_picture_data=b"image data",
+            age=50,
             weight=180.0,
+            insurance_policy_number=98765432101234,
+            emergency_contacts_count=2,
+            completed_visits=3,
+        )
+        Billing.objects.create(
+            account_balance=100.50,
+            payment_duration=timedelta(days=30),
+        )
+        CreditCard.objects.create(
+            card_type="Visa",
+            card_number=1234567890123456,
+            transaction_reference=98765432101234,
+        )
+        Appointment.objects.create(start_time="8:00")
+        PatientPortalUser.objects.create(
+            last_login_ip="127.0.0.1", profile_url="https://example.com"
         )
 
     def test_binaryfield(self):
         self.assertEqual(
-            PatientRecord.objects.get(profile_picture=b"image data").profile_picture, b"image data"
+            PatientRecord.objects.get(profile_picture_data=b"image data").profile_picture_data,
+            b"image data",
         )
 
     def test_booleanfield(self):
         self.assertTrue(Patient.objects.get(patient_id=1).is_active)
 
     def test_charfield(self):
-        CreditCard.objects.create(cc_type="Visa", cc_number="1234567890123456")
-        self.assertEqual(CreditCard.objects.get(cc_type="Visa").cc_type, "Visa")
+        self.assertEqual(CreditCard.objects.get(card_type="Visa").card_type, "Visa")
         self.assertEqual(PatientRecord.objects.get(ssn="123-45-6789").ssn, "123-45-6789")
 
     def test_datefield(self):
@@ -61,36 +77,67 @@ def test_datetimefield(self):
         )
 
     def test_decimalfield(self):
-        Billing.objects.create(account_balance=100.50)
         self.assertTrue(Billing.objects.filter(account_balance__gte=100.0).exists())
 
+    def test_durationfield(self):
+        self.assertTrue(Billing.objects.filter(payment_duration__gte=timedelta(days=15)).exists())
+
     def test_emailfield(self):
         self.assertEqual(
-            Patient.objects.get(email="[email protected]").email, "[email protected]"
+            Patient.objects.get(contact_email="[email protected]").contact_email,
+            "[email protected]",
         )
 
     def test_floatfield(self):
         self.assertTrue(PatientRecord.objects.filter(weight__gte=175.0).exists())
 
     def test_integerfield(self):
-        CreditCard.objects.create(cc_type="Visa", cc_number="1234567890123456")
         self.assertEqual(
-            CreditCard.objects.get(cc_number=1234567890123456).cc_number, 1234567890123456
+            CreditCard.objects.get(card_number=1234567890123456).card_number, 1234567890123456
+        )
+        self.assertEqual(
+            PatientRecord.objects.get(emergency_contacts_count=2).emergency_contacts_count, 2
+        )
+
+    def test_positive_bigintegerfield(self):
+        self.assertEqual(
+            PatientRecord.objects.get(
+                insurance_policy_number=98765432101234
+            ).insurance_policy_number,
+            98765432101234,
+        )
+
+    def test_positive_integerfield(self):
+        self.assertEqual(
+            PatientRecord.objects.get(emergency_contacts_count=2).emergency_contacts_count, 2
+        )
+
+    def test_positive_smallintegerfield(self):
+        self.assertEqual(PatientRecord.objects.get(completed_visits=3).completed_visits, 3)
+
+    def test_bigintegerfield(self):
+        self.assertEqual(
+            CreditCard.objects.get(transaction_reference=98765432101234).transaction_reference,
+            98765432101234,
         )
 
     def test_ipaddressfield(self):
-        PatientPortalUser.objects.create(ip_address="127.0.0.1", url="https://example.com")
         self.assertEqual(
-            PatientPortalUser.objects.get(ip_address="127.0.0.1").ip_address, "127.0.0.1"
+            PatientPortalUser.objects.get(last_login_ip="127.0.0.1").last_login_ip, "127.0.0.1"
         )
 
     def test_smallintegerfield(self):
-        self.assertTrue(PatientRecord.objects.filter(patient_age__gte=40).exists())
-        self.assertFalse(PatientRecord.objects.filter(patient_age__gte=80).exists())
+        self.assertTrue(PatientRecord.objects.filter(age__gte=40).exists())
+        self.assertFalse(PatientRecord.objects.filter(age__gte=80).exists())
+
+    def test_textfield(self):
+        self.assertEqual(
+            Patient.objects.get(notes="patient notes " * 25).notes,
+            "patient notes " * 25,
+        )
 
     def test_timefield(self):
-        Appointment.objects.create(time="8:00")
-        self.assertEqual(Appointment.objects.get(time="8:00").time, time(8, 0))
+        self.assertEqual(Appointment.objects.get(start_time="8:00").start_time, time(8, 0))
 
     def test_encrypted_patient_record_in_encrypted_database(self):
         patients = connections["encrypted"].database.encryption__patient.find()
@@ -102,16 +149,7 @@ def test_encrypted_patient_record_in_unencrypted_database(self):
         conn_params = connections["encrypted"].get_connection_params()
         db_name = settings.DATABASES["encrypted"]["NAME"]
         if conn_params.pop("auto_encryption_opts", False):
-            # Call MongoClient instead of get_new_connection because
-            # get_new_connection will return the encrypted connection
-            # from the connection pool.
             with pymongo.MongoClient(**conn_params) as new_connection:
                 patientrecords = new_connection[db_name].encryption__patientrecord.find()
                 ssn = patientrecords[0]["ssn"]
                 self.assertTrue(isinstance(ssn, Binary))
-
-    def test_textfield(self):
-        self.assertEqual(
-            Patient.objects.get(patient_notes="patient notes " * 25).patient_notes,
-            "patient notes " * 25,
-        )

tests/encryption_/test_management.py

@@ -29,19 +29,30 @@ class CommandTests(TransactionTestCase):
             },
             {
                 "bsonType": "binData",
-                "path": "profile_picture",
+                "path": "profile_picture_data",
                 "queries": {"queryType": "equality"},
             },
             {
                 "bsonType": "int",
-                "path": "patient_age",
+                "path": "age",
                 "queries": {"queryType": "range", "max": 100, "min": 0},
             },
             {
                 "bsonType": "double",
                 "path": "weight",
                 "queries": {"queryType": "range"},
             },
+            {
+                "bsonType": "long",
+                "path": "insurance_policy_number",
+                "queries": {"queryType": "equality"},
+            },
+            {
+                "bsonType": "long",
+                "path": "emergency_contacts_count",
+                "queries": {"queryType": "equality"},
+            },
+            {"bsonType": "int", "path": "completed_visits", "queries": {"queryType": "equality"}},
         ]
     }
 

tests/encryption_/test_schema.py

@@ -27,11 +27,11 @@ def test_get_encrypted_fields_map(self):
                 },
                 {
                     "bsonType": "string",
-                    "path": "patient_name",
+                    "path": "full_name",
                 },
                 {
                     "bsonType": "string",
-                    "path": "patient_notes",
+                    "path": "notes",
                     "queries": {"queryType": "equality"},
                 },
                 {
@@ -46,7 +46,7 @@ def test_get_encrypted_fields_map(self):
                 },
                 {
                     "bsonType": "string",
-                    "path": "email",
+                    "path": "contact_email",
                     "queries": {"queryType": "equality"},
                 },
             ]