Add tests

jsignature/tests/__init__.py

@@ -0,0 +1,4 @@
+from .widgets import JSignatureWidgetTest
+from .forms import JSignatureFormFieldTest
+from .fields import JSignatureFieldTest
+from .mixins import JSignatureFieldsMixinTest

jsignature/tests/fields.py

@@ -0,0 +1,47 @@
+import json
+import django
+from django.test import SimpleTestCase
+from django.core.exceptions import ValidationError
+
+from ..widgets import JSignatureWidget
+from ..fields import JSignatureField
+from ..forms import JSignatureField as JSignatureFormField
+
+
+class JSignatureFieldTest(SimpleTestCase):
+
+    def test_to_python(self):
+        f = JSignatureField()
+        # Empty values
+        for val in ['', [], '[]']:
+            self.assertIsNone(f.to_python(val))
+        # Correct values
+        val = [{"x":[1,2], "y":[3,4]}]
+        self.assertEquals(val, f.to_python(val))
+        val_str = '[{"x":[1,2], "y":[3,4]}]'
+        self.assertEquals(val, f.to_python(val_str))
+        # Incorrect values
+        val = 'foo'
+        self.assertRaises(ValidationError, f.to_python, val)
+
+    def test_get_prep_value(self):
+        f = JSignatureField()
+        # Empty values
+        for val in ['', [], '[]']:
+            self.assertIsNone(f.get_prep_value(val))
+        # Correct values
+        val = [{"x":[1,2], "y":[3,4]}]
+        val_prep = f.get_prep_value(val)
+        self.assertIsInstance(val_prep, basestring)
+        self.assertEquals(val, json.loads(val_prep))
+        val_str = '[{"x":[1,2], "y":[3,4]}]'
+        val_prep = f.get_prep_value(val_str)
+        self.assertIsInstance(val_prep, basestring)
+        self.assertEquals(val, json.loads(val_prep))
+        # Incorrect values
+        val = type('Foo')
+        self.assertRaises(ValidationError, f.get_prep_value, val)
+
+    def test_formfield(self):
+        f = JSignatureField()
+        self.assertTrue(issubclass(f.formfield().__class__, JSignatureFormField))

jsignature/tests/forms.py

@@ -0,0 +1,26 @@
+import json
+import django
+from django.test import SimpleTestCase
+from django.core.exceptions import ValidationError
+
+from ..widgets import JSignatureWidget
+from ..forms import JSignatureField
+
+
+class JSignatureFormFieldTest(SimpleTestCase):
+
+    def test_widget(self):
+        f = JSignatureField()
+        self.assertIsInstance(f.widget, JSignatureWidget)
+
+    def test_to_python(self):
+        f = JSignatureField()
+        # Empty values
+        for val in ['', [], '[]']:
+            self.assertIsNone(f.to_python(val))
+        # Correct values
+        val = '[{"x":[1,2], "y":[3,4]}]'
+        self.assertEquals([{'x':[1,2], 'y':[3,4]}], f.to_python(val))
+        # Incorrect values
+        val = 'foo'
+        self.assertRaises(ValidationError, f.to_python, val)

jsignature/tests/mixins.py

@@ -0,0 +1,50 @@
+import json
+import django
+from datetime import datetime, date
+from django.conf import settings
+from django.db.models import loading
+from django.test import SimpleTestCase
+from django.core.management import call_command
+from django.core.exceptions import ValidationError
+
+from .models import JSignatureTestModel
+
+
+class JSignatureFieldsMixinTest(SimpleTestCase):
+
+    def setUp(self):
+        self.old_installed_apps = settings.INSTALLED_APPS
+        settings.INSTALLED_APPS = list(settings.INSTALLED_APPS)
+        settings.INSTALLED_APPS.append('jsignature.tests')
+        loading.cache.loaded = False
+        call_command('syncdb', verbosity=0)
+
+    def tearDown(self):
+        settings.INSTALLED_APPS = self.old_installed_apps
+
+    def test_save(self):
+        # If an object is created signed, signature date must be set
+        signature_value = [{"x":[1,2], "y":[3,4]}]
+        i = JSignatureTestModel(signature=signature_value)
+        i.save()
+        i = JSignatureTestModel.objects.get(pk=i.pk)
+        self.assertEqual(date.today(), i.signature_date.date())
+
+        # If signature doesn't change, signature date must not be updated
+        i = JSignatureTestModel(signature=signature_value)
+        i.save()
+        i.signature_date = date(2013, 1, 1)
+        i.signature = signature_value
+        i.save()
+        i = JSignatureTestModel.objects.get(pk=i.pk)
+        self.assertEqual(date(2013, 1, 1), i.signature_date.date())
+
+        # If signature changes, signature date must be updated too
+        new_signature_value = [{"x":[5,6], "y":[7,8]}]
+        i = JSignatureTestModel(signature=signature_value, signature_date=date(2013, 1, 1))
+        i.save()
+        i.signature_date = date(2013, 1, 1)
+        i.signature = new_signature_value
+        i.save()
+        i = JSignatureTestModel.objects.get(pk=i.pk)
+        self.assertEqual(date.today(), i.signature_date.date())

jsignature/tests/models.py

@@ -0,0 +1,5 @@
+""" Provides a dummy model implementing JSignatureFieldsMixin """
+from ..mixins import JSignatureFieldsMixin
+
+class JSignatureTestModel(JSignatureFieldsMixin):
+    pass

jsignature/tests/widgets.py

@@ -0,0 +1,65 @@
+import json
+import django
+from django.test import SimpleTestCase
+from django.core.exceptions import ValidationError
+
+from ..widgets import JSignatureWidget
+from ..settings import JSIGNATURE_HEIGHT
+
+
+class JSignatureWidgetTest(SimpleTestCase):
+
+    def test_default_media(self):
+        widget = JSignatureWidget()
+        media = widget.media
+        media_js = list(media.render_js())
+        self.assertEqual(2, len(media_js))
+        media_js_str = "".join(media_js)
+        self.assertIn('jSignature.min.js', media_js_str)
+        self.assertIn('django_jsignature.js', media_js_str)
+        media_css = list(media.render_css())
+        self.assertEquals([], media_css)
+
+    def test_init(self):
+        w = JSignatureWidget()
+        self.assertEquals({}, w.jsignature_attrs)
+        given_attrs = {'width': 300, 'height': 100}
+        w = JSignatureWidget(jsignature_attrs=given_attrs)
+        self.assertEquals(given_attrs, w.jsignature_attrs)
+
+    def test_build_jsignature_id(self):
+        w = JSignatureWidget()
+        id = w.build_jsignature_id('foo')
+        self.assertEqual('jsign_foo', id)
+
+    def test_build_jsignature_config(self):
+        w = JSignatureWidget(jsignature_attrs={'width': 400})
+        config = w.build_jsignature_config()
+        self.assertEqual(400, config.get('width'))
+        self.assertEqual(JSIGNATURE_HEIGHT, config.get('height'))
+
+    def test_prep_value(self):
+        w = JSignatureWidget()
+        # Empty values
+        for val in ['', [], '[]']:
+            self.assertEqual('[]', w.prep_value(val))
+        # Correct values
+        val = [{"x":[1,2], "y":[3,4]}]
+        val_prep = w.prep_value(val)
+        self.assertIsInstance(val_prep, basestring)
+        self.assertEquals(val, json.loads(val_prep))
+        val_str = '[{"x":[1,2], "y":[3,4]}]'
+        val_prep = w.prep_value(val_str)
+        self.assertIsInstance(val_prep, basestring)
+        self.assertEquals(val, json.loads(val_prep))
+        # Incorrect values
+        val = type('Foo')
+        self.assertRaises(ValidationError, w.prep_value, val)
+
+    def test_render(self):
+        w = JSignatureWidget()
+        output = w.render(name='foo', value=None)
+        # Almost useless :/
+        self.assertIn('class="jsign-wrapper"', output)
+        self.assertIn('type="hidden"', output)
+        self.assertIn('type="text/javascript"', output)