minor tests cleanup

Author: saxix

.travis.yml

@@ -46,7 +46,7 @@ install:
   - pip install tox "coverage<=4.0" python-coveralls>=2.5 coveralls>=0.5 codecov
 
 script:
-  - tox -e "py${TRAVIS_PYTHON_VERSION//.}-d${DJANGO//.}-${DB}" -- py.test tests -v -W ignore::DeprecationWarning --capture=no --cov=concurrency --cov-report=xml --cov-config=tests/.coveragerc
+  - tox -e "py${TRAVIS_PYTHON_VERSION//.}-d${DJANGO//.}-${DB}" -- py.test tests src/concurrency -v
 
 before_success:
   - coverage erase

src/concurrency/admin.py

@@ -38,7 +38,7 @@ def action_checkbox(self, obj):
             return helpers.checkbox.render(helpers.ACTION_CHECKBOX_NAME,
                                            force_text("%s,%s" % (obj.pk,
                                                                  get_revision_of_object(obj))))
-        else:
+        else:  # pragma: no cover
             return super(ConcurrencyActionMixin, self).action_checkbox(obj)
 
     action_checkbox.short_description = mark_safe('<input type="checkbox" id="action-toggle" />')
@@ -69,7 +69,7 @@ def response_action(self, request, queryset):  # noqa
         # Use the action whose button was pushed
         try:
             data.update({'action': data.getlist('action')[action_index]})
-        except IndexError:
+        except IndexError:  # pragma: no cover
             # If we didn't get an action from the chosen form that's invalid
             # POST data, so by deleting action it'll fail the validation check
             # below. So no need to do anything here
@@ -90,10 +90,11 @@ def response_action(self, request, queryset):  # noqa
             else:
                 selected = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)
 
-            revision_field = self.model._concurrencymeta.field
             if not selected:
                 return None
 
+            revision_field = self.model._concurrencymeta.field
+
             if self.check_concurrent_action:
                 self.delete_selected_confirmation_template = self.get_confirmation_template()
 

src/concurrency/api.py

@@ -8,6 +8,7 @@
 from concurrency.config import conf
 from concurrency.core import _select_lock, get_version_fieldname  # _wrap_model_save
 from concurrency.exceptions import RecordModifiedError
+from concurrency.utils import deprecated
 
 __all__ = ['apply_concurrency_check', 'concurrency_check', 'get_revision_of_object',
            'RecordModifiedError', 'disable_concurrency',
@@ -66,10 +67,11 @@ def apply_concurrency_check(model, fieldname, versionclass):
 
     class_prepared_concurrency_handler(model)
 
-    if not model._concurrencymeta.versioned_save:
-        versionclass._wrap_model_save(model)
+    # if not model._concurrencymeta.versioned_save:
+    #     versionclass._wrap_model_save(model)
 
 
+@deprecated(version="1.5")
 def concurrency_check(model_instance, force_insert=False, force_update=False, using=None, **kwargs):
     if not force_insert:
         _select_lock(model_instance)

src/concurrency/compat.py

@@ -15,4 +15,4 @@
 try:
     from django.urls.utils import get_callable
 except ImportError:
-    from django.core.urlresolvers import get_callable
+    from django.core.urlresolvers import get_callable  # noqa

src/concurrency/config.py

@@ -23,27 +23,29 @@ class AppSettings(object):
     """
     Class to manage application related settings
     How to use:
-
+    >>> import pytest
     >>> from django.conf import settings
+    >>> from concurrency.utils import fqn
     >>> settings.APP_OVERRIDE = 'overridden'
-    >>> settings.MYAPP_CALLBACK = 100
     >>> class MySettings(AppSettings):
-    ...     defaults = {'ENTRY1': 'abc', 'ENTRY2': 123, 'OVERRIDE': None, 'CALLBACK':10}
-    ...     def set_CALLBACK(self, value):
-    ...         setattr(self, 'CALLBACK', value*2)
+    ...     defaults = {'ENTRY1': 'abc', 'ENTRY2': 123, 'OVERRIDE': None, 'CALLBACK': fqn(fqn)}
 
     >>> conf = MySettings("APP")
-    >>> conf.ENTRY1, settings.APP_ENTRY1
+    >>> str(conf.ENTRY1), str(settings.APP_ENTRY1)
     ('abc', 'abc')
-    >>> conf.OVERRIDE, settings.APP_OVERRIDE
+    >>> str(conf.OVERRIDE), str(settings.APP_OVERRIDE)
     ('overridden', 'overridden')
 
     >>> conf = MySettings("MYAPP")
     >>> conf.ENTRY2, settings.MYAPP_ENTRY2
     (123, 123)
+    >>> settings.MYAPP_CALLBACK = fqn
     >>> conf = MySettings("MYAPP")
-    >>> conf.CALLBACK
-    200
+    >>> conf.CALLBACK == fqn
+    True
+    >>> with pytest.raises(ImproperlyConfigured):
+    ...     settings.OTHER_CALLBACK = 222
+    ...     conf = MySettings("OTHER")
 
     """
     defaults = {
@@ -81,7 +83,7 @@ def _set_attr(self, prefix_name, value):
             elif callable(value):
                 func = value
             else:
-                raise ImproperlyConfigured("`CALLBACK` must be a callable or a fullpath to callable")
+                raise ImproperlyConfigured("{} is not a valid value for `CALLBACK`. It must be a callable or a fullpath to callable. ".format(value))
             self._callback = func
 
         setattr(self, name, value)

src/concurrency/management/commands/triggers.py

@@ -76,5 +76,5 @@ def handle(self, *args, **options):
                     self.stdout.write('')
                 else:
                     raise Exception()
-            except ImproperlyConfigured as e:
+            except ImproperlyConfigured as e:  # pragma: no cover
                 self.stdout.write(self.style.ERROR(e))

src/concurrency/triggers.py

@@ -9,6 +9,7 @@
 
 from .fields import _TRIGGERS  # noqa
 
+
 def get_trigger_name(field):
     """
 
@@ -48,6 +49,8 @@ def drop_triggers(*databases):
             f.drop(field)
             field._trigger_exists = False
             ret[alias].append([model, field, field.trigger_name])
+        else:  # pragma: no cover
+            pass
     return ret
 
 
@@ -60,14 +63,15 @@ def create_triggers(databases):
         field = model._concurrencymeta.field
         storage = model._concurrencymeta.triggers
         alias = router.db_for_write(model)
-        if alias in databases:
-            if field not in storage:
-                storage.append(field)
-                connection = connections[alias]
-                f = factory(connection)
-                f.create(field)
-                ret[alias].append([model, field, field.trigger_name])
-    # _TRIGGERS = []
+        if (alias in databases) and field not in storage:
+            storage.append(field)
+            connection = connections[alias]
+            f = factory(connection)
+            f.create(field)
+            ret[alias].append([model, field, field.trigger_name])
+        else:  # pragma: no cover
+            pass
+
     return ret
 
 
@@ -168,5 +172,5 @@ def factory(conn):
                 'sqlite3': Sqlite3,
                 'sqlite': Sqlite3,
                 }[conn.vendor](conn)
-    except KeyError:
+    except KeyError:  # pragma: no cover
         raise ValueError('{} is not supported by TriggerVersionField'.format(conn))

src/concurrency/utils.py

@@ -14,32 +14,26 @@ def deprecated(replacement=None, version=None):
     """A decorator which can be used to mark functions as deprecated.
     replacement is a callable that will be called with the same args
     as the decorated function.
-
+    >>> import pytest
     >>> @deprecated()
-    ... def foo(x):
+    ... def foo1(x):
     ...     return x
     ...
-    >>> ret = foo(1)
-    DeprecationWarning: foo is deprecated
-    >>> ret
+    >>> pytest.warns(DeprecationWarning, foo1, 1)
     1
-    >>>
-    >>>
     >>> def newfun(x):
     ...     return 0
     ...
-    >>> @deprecated(newfun)
-    ... def foo(x):
+    >>> @deprecated(newfun, '1.1')
+    ... def foo2(x):
     ...     return x
     ...
-    >>> ret = foo(1)
-    DeprecationWarning: foo is deprecated; use newfun instead
-    >>> ret
+    >>> pytest.warns(DeprecationWarning, foo2, 1)
     0
     >>>
     """
 
-    def outer(oldfun):  # pragma: no cover
+    def outer(oldfun):
         def inner(*args, **kwargs):
             msg = "%s is deprecated" % oldfun.__name__
             if version is not None:
@@ -148,20 +142,27 @@ def fqn(o):
     :param o: object or class
     :return: class name
 
+    >>> import concurrency.fields
     >>> fqn('str')
     Traceback (most recent call last):
     ...
     ValueError: Invalid argument `str`
-    >>> class A(object): pass
-    >>> fqn(A)
-    'wfp_commonlib.python.reflect.A'
+    >>> class A(object):
+    ...     def method(self):
+    ...         pass
+    >>> str(fqn(A))
+    'concurrency.utils.A'
+
+    >>> str(fqn(A()))
+    'concurrency.utils.A'
+
+    >>> str(fqn(concurrency.fields))
+    'concurrency.fields'
+
+    >>> str(fqn(A.method))
+    'concurrency.utils.A.method'
 
-    >>> fqn(A())
-    'wfp_commonlib.python.reflect.A'
 
-    >>> from wfp_commonlib.python import RexList
-    >>> fqn(RexList.append)
-    'wfp_commonlib.python.structure.RexList.append'
     """
     parts = []
 

src/concurrency/views.py

@@ -30,14 +30,14 @@ def conflict(request, target=None, template_name='409.html'):
     """
     try:
         template = loader.get_template(template_name)
-    except TemplateDoesNotExist:
+    except TemplateDoesNotExist:  # pragma: no cover
         template = Template(
             '<h1>Conflict</h1>'
             '<p>The request was unsuccessful due to a conflict. '
             'The object changed during the transaction.</p>')
     try:
         saved = target.__class__._default_manager.get(pk=target.pk)
-    except target.__class__.DoesNotExist:
+    except target.__class__.DoesNotExist:  # pragma: no cover
         saved = None
     ctx = {'target': target,
            'saved': saved,

tests/test_api.py

@@ -51,3 +51,9 @@ def test_apply_concurrency_check():
 
     with pytest.raises(RecordModifiedError):
         instance.save()
+
+
+@pytest.mark.django_db(transaction=False)
+def test_apply_concurrency_check_ignore_multiple_call():
+    apply_concurrency_check(Group, 'version', IntegerVersionField)
+    apply_concurrency_check(Group, 'version', IntegerVersionField)