django-spire 0.23.6__py3-none-any.whl → 0.23.8__py3-none-any.whl

django_spire/contrib/session/tests/test_session_controller.py

@@ -1,18 +1,21 @@
+from __future__ import annotations
+
 from datetime import datetime
+from unittest.mock import MagicMock
 
-from django.test import TestCase, RequestFactory
 from django.contrib.sessions.middleware import SessionMiddleware
 from django.contrib.sessions.models import Session
+from django.test import RequestFactory, TestCase
 
 from django_spire.contrib.session.controller import SessionController
+from django_spire.contrib.session.templatetags.session_tags import session_controller_to_json
 
 
-class BaseSessionTestCase(TestCase):
-    def setUp(self):
+class TestSessionController(TestCase):
+    def setUp(self) -> None:
         self.factory = RequestFactory()
         self.request = self.factory.get('/')
 
-        # Attach real session
         middleware = SessionMiddleware(lambda req: None)
         middleware.process_request(self.request)
 
@@ -21,85 +24,146 @@ class BaseSessionTestCase(TestCase):
             session_key='shopping_cart'
         )
 
-    def test_base_session_add_data(self):
+    def test_add_data(self) -> None:
         key = 'currency'
         value = 'CAD'
 
         self.shopping_cart_session.add_data(key, value)
-        self.assertIn(key, self.shopping_cart_session.data)
-        self.assertEqual(self.shopping_cart_session.data[key], value)
 
-    def test_base_session_set_item(self):
-        key = 'currency'
-        value = 'CAD'
+        assert key in self.shopping_cart_session.data
+        assert self.shopping_cart_session.data[key] == value
 
-        self.shopping_cart_session[key] = value
-        self.assertIn(key, self.shopping_cart_session.data)
-        self.assertEqual(self.shopping_cart_session.data[key], value)
+    def test_data_property_returns_dict(self) -> None:
+        assert isinstance(self.shopping_cart_session.data, dict)
 
-    def test_base_session_remove_data(self):
+    def test_getitem(self) -> None:
         self.shopping_cart_session.add_data('currency', 'CAD')
-        self.shopping_cart_session.add_data('discount', None)
-        self.shopping_cart_session.remove_data('currency')
 
-        self.assertNotIn('currency', self.shopping_cart_session.data)
-        self.assertIn('discount', self.shopping_cart_session.data)
+        assert self.shopping_cart_session['currency'] == 'CAD'
 
-    def test_set_session_modified(self):
+    def test_has_data_false_when_empty(self) -> None:
+        assert self.shopping_cart_session.has_data is False
+
+    def test_has_data_true_when_data_exists(self) -> None:
         self.shopping_cart_session.add_data('currency', 'CAD')
-        self.assertTrue(self.request.session.modified)
 
-    def test_session_has_data(self):
-        self.assertFalse(self.shopping_cart_session.has_data)
+        assert self.shopping_cart_session.has_data is True
 
+    def test_has_data_false_after_remove(self) -> None:
         self.shopping_cart_session.add_data('currency', 'CAD')
-        self.assertTrue(self.shopping_cart_session.has_data)
+        self.shopping_cart_session.remove_data('currency')
 
+        assert self.shopping_cart_session.has_data is False
 
-        self.shopping_cart_session.remove_data('currency')
-        self.assertFalse(self.shopping_cart_session.has_data)
+    def test_is_expired_false_when_not_expired(self) -> None:
+        self.shopping_cart_session.add_data('currency', 'CAD')
 
-    def test_session_data_to_json(self):
+        assert self.shopping_cart_session.is_expired is False
+
+    def test_is_expired_true_when_expired(self) -> None:
         self.shopping_cart_session.add_data('currency', 'CAD')
-        self.shopping_cart_session.add_data('discount', None)
+        self.shopping_cart_session.seconds_till_expiry = -5
+        self.shopping_cart_session._set_timeout_datestamp()
 
-        self.assertTrue(isinstance(self.shopping_cart_session.to_json(), str))
+        assert self.shopping_cart_session.is_expired is True
 
-    # def test_to_json_errors_when_not_json_serializable(self):
-    #     self.shopping_cart_session.json_serializable = False
-    #
-    #     with self.assertRaises(ValueError):
-    #         self.shopping_cart_session.to_json()
+    def test_purge_removes_session_data(self) -> None:
+        self.shopping_cart_session.add_data('currency', 'CAD')
+        self.shopping_cart_session.purge()
 
-    def test_set_timeout_datestamp(self):
-        self.shopping_cart_session._set_timeout_datestamp()
-        self.assertIn('_timeout_datestamp', self.shopping_cart_session.data)
-        self.assertTrue(datetime.now().timestamp() < self.shopping_cart_session['_timeout_datestamp'])
+        assert 'shopping_cart' not in self.request.session
 
-    def test_session_data_expiry(self):
+    def test_remove_data(self) -> None:
         self.shopping_cart_session.add_data('currency', 'CAD')
-        self.assertFalse(self.shopping_cart_session.is_expired)
+        self.shopping_cart_session.add_data('discount', None)
+        self.shopping_cart_session.remove_data('currency')
 
-        self.shopping_cart_session.seconds_till_expiry = -5
-        self.shopping_cart_session._set_timeout_datestamp()
-        self.assertTrue(self.shopping_cart_session.is_expired)
+        assert 'currency' not in self.shopping_cart_session.data
+        assert 'discount' in self.shopping_cart_session.data
 
-    def test_session_data_added_to_database(self):
-        # Add something to the session
-        self.shopping_cart_session.add_data('favorites', ['cool_shirt', 'fun_hat'] )
+    def test_session_data_added_to_database(self) -> None:
+        self.shopping_cart_session.add_data('favorites', ['cool_shirt', 'fun_hat'])
         self.request.session.save()
 
-        # Get session from DB using session_key
         session_key = self.request.session.session_key
         session_in_db = Session.objects.get(session_key=session_key)
-
-        # Decode the session data
         session_data = session_in_db.get_decoded()
 
-        self.assertIn(self.shopping_cart_session.session_key, session_data)
-        self.assertIn('favorites', session_data[self.shopping_cart_session.session_key])
-        self.assertEqual(
-            session_data[self.shopping_cart_session.session_key]['favorites'],
-            ['cool_shirt', 'fun_hat']
+        assert self.shopping_cart_session.session_key in session_data
+        assert 'favorites' in session_data[self.shopping_cart_session.session_key]
+        assert session_data[self.shopping_cart_session.session_key]['favorites'] == ['cool_shirt', 'fun_hat']
+
+    def test_set_modified(self) -> None:
+        self.shopping_cart_session.add_data('currency', 'CAD')
+
+        assert self.request.session.modified is True
+
+    def test_set_timeout_datestamp(self) -> None:
+        self.shopping_cart_session._set_timeout_datestamp()
+
+        assert '_timeout_datestamp' in self.shopping_cart_session.data
+        assert datetime.now().timestamp() < self.shopping_cart_session['_timeout_datestamp']
+
+    def test_setitem(self) -> None:
+        key = 'currency'
+        value = 'CAD'
+
+        self.shopping_cart_session[key] = value
+
+        assert key in self.shopping_cart_session.data
+        assert self.shopping_cart_session.data[key] == value
+
+    def test_timeout_datestamp_returns_float(self) -> None:
+        self.shopping_cart_session._set_timeout_datestamp()
+
+        assert isinstance(self.shopping_cart_session.timeout_datestamp, float)
+
+    def test_timeout_datestamp_returns_zero_when_not_set(self) -> None:
+        controller = SessionController(
+            request=self.request,
+            session_key='new_session'
         )
 
+        assert controller.timeout_datestamp == 0
+
+    def test_to_json_returns_string(self) -> None:
+        self.shopping_cart_session.add_data('currency', 'CAD')
+        self.shopping_cart_session.add_data('discount', None)
+
+        assert isinstance(self.shopping_cart_session.to_json(), str)
+
+
+class TestSessionControllerToJson(TestCase):
+    def setUp(self) -> None:
+        self.factory = RequestFactory()
+
+    def _create_context_with_session(self) -> MagicMock:
+        request = self.factory.get('/')
+        middleware = SessionMiddleware(lambda req: None)
+        middleware.process_request(request)
+
+        context = MagicMock()
+        context.get.return_value = request
+
+        return context
+
+    def test_returns_escaped_json(self) -> None:
+        context = self._create_context_with_session()
+
+        result = session_controller_to_json(context, 'test_key')
+
+        assert isinstance(result, str)
+
+    def test_calls_context_get_with_request(self) -> None:
+        context = self._create_context_with_session()
+
+        session_controller_to_json(context, 'test_key')
+
+        context.get.assert_called_once_with('request')
+
+    def test_returns_safe_string(self) -> None:
+        context = self._create_context_with_session()
+
+        result = session_controller_to_json(context, 'test_key')
+
+        assert hasattr(result, '__html__')

django_spire/contrib/tests/test_utils.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from django.test import TestCase
+
+from django_spire.contrib.utils import truncate_string
+
+
+class TestTruncateString(TestCase):
+    def test_returns_original_when_equal_to_length(self) -> None:
+        result = truncate_string('hello', 5)
+
+        assert result == 'hello'
+
+    def test_returns_original_when_shorter_than_length(self) -> None:
+        result = truncate_string('hi', 10)
+
+        assert result == 'hi'
+
+    def test_truncates_when_longer_than_length(self) -> None:
+        result = truncate_string('hello world', 8)
+
+        assert result == 'hello...'
+
+    def test_truncates_with_ellipsis(self) -> None:
+        result = truncate_string('this is a long string', 10)
+
+        assert result.endswith('...')
+
+    def test_truncated_length_equals_specified_length(self) -> None:
+        result = truncate_string('this is a long string', 10)
+
+        assert len(result) == 10
+
+    def test_empty_string(self) -> None:
+        result = truncate_string('', 5)
+
+        assert result == ''

django_spire/contrib/utils.py

@@ -1,2 +1,5 @@
+from __future__ import annotations
+
+
 def truncate_string(string: str, length: int) -> str:
-    return string[:(length - 3)] + '...' if len(string) > length else string
+    return string[:(length - 3)] + '...' if len(string) > length else string

django_spire/core/apps.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.apps import AppConfig
 
 

django_spire/core/converters/tests/test_to_data.py

@@ -0,0 +1,353 @@
+from __future__ import annotations
+
+import datetime
+
+from unittest import TestCase
+from uuid import UUID
+
+from django.core.validators import MaxValueValidator, MinValueValidator
+from django.db import models
+
+from django_spire.core.converters.to_data import DjangoFieldToFakerData, fake_model_field_value
+
+
+class TestDjangoFieldToFakerData(TestCase):
+    def test_binary_field_data(self) -> None:
+        class BinaryModel(models.Model):
+            data = models.BinaryField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = BinaryModel._meta.get_field('data')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, bytes)
+        assert len(result) == 16
+
+    def test_boolean_field_data(self) -> None:
+        class BooleanModel(models.Model):
+            is_active = models.BooleanField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = BooleanModel._meta.get_field('is_active')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, bool)
+
+    def test_char_field_data(self) -> None:
+        class CharModel(models.Model):
+            name = models.CharField(max_length=50)
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = CharModel._meta.get_field('name')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, str)
+        assert len(result) <= 50
+
+    def test_char_field_with_choices(self) -> None:
+        class ChoicesModel(models.Model):
+            status = models.CharField(
+                max_length=10,
+                choices=[('A', 'Active'), ('I', 'Inactive')]
+            )
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = ChoicesModel._meta.get_field('status')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert result in ['A', 'I']
+
+    def test_custom_faker_method(self) -> None:
+        class CustomFakerModel(models.Model):
+            name = models.CharField(max_length=100)
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = CustomFakerModel._meta.get_field('name')
+        result = DjangoFieldToFakerData(field, faker_method=('first_name',)).convert()
+
+        assert isinstance(result, str)
+
+    def test_custom_faker_method_with_kwargs(self) -> None:
+        class CustomFakerKwargsModel(models.Model):
+            number = models.IntegerField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = CustomFakerKwargsModel._meta.get_field('number')
+        result = DjangoFieldToFakerData(
+            field,
+            faker_method=('random_int', {'min': 100, 'max': 200})
+        ).convert()
+
+        assert isinstance(result, int)
+        assert 100 <= result <= 200
+
+    def test_date_field_data(self) -> None:
+        class DateModel(models.Model):
+            created = models.DateField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = DateModel._meta.get_field('created')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, datetime.date)
+
+    def test_date_time_field_data(self) -> None:
+        class DateTimeModel(models.Model):
+            created_at = models.DateTimeField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = DateTimeModel._meta.get_field('created_at')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, datetime.datetime)
+
+    def test_decimal_field_data(self) -> None:
+        class DecimalModel(models.Model):
+            price = models.DecimalField(max_digits=10, decimal_places=2)
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = DecimalModel._meta.get_field('price')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, float)
+
+    def test_email_field_data(self) -> None:
+        """EmailField.get_internal_type() returns 'CharField', so it uses _char_field_data"""
+
+        class EmailModel(models.Model):
+            email = models.EmailField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = EmailModel._meta.get_field('email')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, str)
+
+    def test_integer_field_data(self) -> None:
+        class IntegerModel(models.Model):
+            count = models.IntegerField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = IntegerModel._meta.get_field('count')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, int)
+
+    def test_integer_field_with_validators(self) -> None:
+        class IntegerValidatorModel(models.Model):
+            count = models.IntegerField(
+                validators=[MinValueValidator(10), MaxValueValidator(20)]
+            )
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = IntegerValidatorModel._meta.get_field('count')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, int)
+        assert 10 <= result <= 20
+
+    def test_positive_integer_field_data(self) -> None:
+        class PositiveIntegerModel(models.Model):
+            count = models.PositiveIntegerField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = PositiveIntegerModel._meta.get_field('count')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, int)
+        assert result >= 0
+
+    def test_slug_field_data(self) -> None:
+        class SlugModel(models.Model):
+            slug = models.SlugField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = SlugModel._meta.get_field('slug')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, str)
+
+    def test_text_field_data(self) -> None:
+        class TextModel(models.Model):
+            description = models.TextField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = TextModel._meta.get_field('description')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, str)
+
+    def test_time_field_data(self) -> None:
+        class TimeModel(models.Model):
+            start_time = models.TimeField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = TimeModel._meta.get_field('start_time')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, str)
+
+    def test_url_field_data(self) -> None:
+        """URLField.get_internal_type() returns 'CharField', so it uses _char_field_data"""
+
+        class UrlModel(models.Model):
+            website = models.URLField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = UrlModel._meta.get_field('website')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, str)
+
+    def test_uuid_field_data(self) -> None:
+        class UuidModel(models.Model):
+            uuid = models.UUIDField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        field = UuidModel._meta.get_field('uuid')
+        result = DjangoFieldToFakerData(field).convert()
+
+        assert isinstance(result, str)
+        UUID(result)
+
+
+class TestFakeModelFieldValue(TestCase):
+    def test_fake_model_field_value(self) -> None:
+        class FakeValueModel(models.Model):
+            name = models.CharField(max_length=50)
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        result = fake_model_field_value(FakeValueModel, 'name')
+
+        assert isinstance(result, str)
+        assert len(result) <= 50
+
+    def test_fake_model_field_value_with_faker_method(self) -> None:
+        class FakeValueFakerModel(models.Model):
+            email = models.EmailField()
+
+            class Meta:
+                managed = False
+                app_label = 'test_to_data'
+
+            def __str__(self) -> str:
+                return 'model'
+
+        result = fake_model_field_value(FakeValueFakerModel, 'email', faker_method=('email',))
+
+        assert isinstance(result, str)
+        assert '@' in result