diff --git a/coverage.rc b/.coveragerc
similarity index 100%
rename from coverage.rc
rename to .coveragerc
diff --git a/.travis.yml b/.travis.yml
index 2b81084..d377f9f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -8,32 +8,32 @@ python:
 
 
 env:
-  - DJANGO=django==1.4.15
-  - DJANGO=django==1.5.10
-  - DJANGO=django==1.6.7
-  - DJANGO=django==1.7
+  - DJANGO=django==1.4.18
+  - DJANGO=django==1.5.12
+  - DJANGO=django==1.6.10
+  - DJANGO=django==1.7.3
 
 
 matrix:
   exclude:
     - python: "2.6"
-      env: DJANGO=django==1.7
+      env: DJANGO=django==1.7.3
     - python: "3.3"
-      env: DJANGO=django==1.4.15
+      env: DJANGO=django==1.4.18
     - python: "3.4"
-      env: DJANGO=django==1.4.15
+      env: DJANGO=django==1.4.18
 
 
 install:
   - pip install -q $DJANGO
-  - pip install -q flake8
+  - pip install -q flake8 coverage coveralls
   - python setup.py install
 
 before_script:
   - make flake8
 
 script:
-  - make test
+  - make coverage
 
 after_success:
   - make coveralls
diff --git a/CHANGELOG.rst b/CHANGELOG.rst
new file mode 100644
index 0000000..d961509
--- /dev/null
+++ b/CHANGELOG.rst
@@ -0,0 +1,20 @@
+Changes
+=======
+
+0.1
+---
+
+* Permissions for disguise now linked with User model;
+* Using django system check framework in newest versions;
+* Disguise widget become a template tag; earlier it added into page with middleware;
+* Migrated to CBV views;
+* Code imporvements (pep8);
+* Added coverage support;
+* Added signals;
+* Removed the ``update_user_login`` feature prior to custom signal handling;
+
+
+0.0.3
+-----
+
+* Travis CI integration
diff --git a/Makefile b/Makefile
index 49bfac5..0b2a70f 100644
--- a/Makefile
+++ b/Makefile
@@ -1,23 +1,26 @@
 test:
 	python setup.py test
 
+
 release:
 	python setup.py sdist --format=zip,bztar,gztar register upload
+	python setup.py bdist_wheel register upload
 
 
 flake8:
-	flake8 --ignore=E501 disguise
-	flake8 --ignore=E501 tests.py
-	flake8 --ignore=E501 setup.py
+	flake8 \
+		disguise \
+		tests.py \
+		setup.py
 
 
 coverage:
-	coverage run --include=disguise/*.py setup.py test
+	coverage run --rcfile=.coveragerc --include=disguise/*.py setup.py test
 	coverage html
 
 
 coveralls:
-	coveralls --config_file=coverage.rc
+	coveralls
 
 clean:
 	rm -rf *.egg *.egg-info
diff --git a/disguise/__init__.py b/disguise/__init__.py
index e69de29..1f6693a 100644
--- a/disguise/__init__.py
+++ b/disguise/__init__.py
@@ -0,0 +1,6 @@
+# coding: utf-8
+
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
diff --git a/disguise/compat.py b/disguise/compat.py
new file mode 100644
index 0000000..df7ac9c
--- /dev/null
+++ b/disguise/compat.py
@@ -0,0 +1,25 @@
+# coding: utf-8
+
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+
+
+try:
+    from django.contrib.auth import get_user_model
+except ImportError:
+    from django.contrib.auth.models import User
+    get_user_model = lambda: User
+
+try:
+    from django.core import checks
+    assert hasattr(checks, 'Error')
+except (ImportError, AssertionError):
+    from django.core.exceptions import ImproperlyConfigured
+
+    class Checks(object):
+        class Error(object):
+            def __init__(self, message, hint='', error='', id=''):
+                raise ImproperlyConfigured(message, id)
+    checks = Checks()
diff --git a/disguise/const.py b/disguise/const.py
new file mode 100644
index 0000000..27a7c8d
--- /dev/null
+++ b/disguise/const.py
@@ -0,0 +1,14 @@
+# coding: utf-8
+
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+from django.contrib.auth import SESSION_KEY, BACKEND_SESSION_KEY
+
+KEYNAME = 'django_disguise:original_user'
+TAGNAME = 'body'
+BACKEND = 'django.contrib.auth.backends.ModelBackend'
+
+__all__ = ['KEYNAME', 'TAGNAME', 'SESSION_KEY', 'BACKEND_SESSION_KEY',
+           'BACKEND']
diff --git a/disguise/forms.py b/disguise/forms.py
index a3d2afe..8adec72 100644
--- a/disguise/forms.py
+++ b/disguise/forms.py
@@ -1,36 +1,37 @@
+# coding: utf-8
+
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
 from django import forms
 from django.utils.translation import ugettext_lazy as _
+from disguise.compat import get_user_model
+
 
-try:
-    from django.contrib.auth import get_user_model
-    User = get_user_model()
-except ImportError:
-    from django.contrib.auth.models import User
+User = get_user_model()
 
 
 class DisguiseForm(forms.Form):
     """
     Disguise form
     """
-    username = forms.CharField(label=_('User name'),
-                               required=False)
-    user_id = forms.IntegerField(label=_('User ID'),
-                                 required=False)
-    update_last_login = forms.BooleanField(label=_('Update last login'),
-                                           required=False)
+    username = forms.CharField(label=_('User name'), required=False)
+    user_id = forms.IntegerField(label=_('User ID'), required=False)
 
     def clean_username(self):
         """
         Cleans username field
         """
         username = self.cleaned_data.get('username')
+
         if not username:
             return None
 
         qset = User.objects.filter(username=username)
 
-        if len(qset) == 1:
-            return qset[0]
+        if qset.exists():
+            return qset.get()
         raise forms.ValidationError(_('No such username'))
 
     def clean_user_id(self):
@@ -43,16 +44,21 @@ def clean_user_id(self):
             return None
         qset = User.objects.filter(pk=user_id)
 
-        if len(qset) == 1:
-            return qset[0]
+        if qset.exists():
+            return qset.get()
         raise forms.ValidationError(_('No such user id'))
 
     def clean(self):
         """
         Clears whole form totally
         """
-        if not getattr(self, 'cleaned_data'):
-            raise forms.ValidationError(_('No such username or user id'))
+        cleaned_data = getattr(self, 'cleaned_data', {})
+
+        if not cleaned_data.get('user_id') and \
+                not cleaned_data.get('username'):
+            raise forms.ValidationError(
+                _('Please enter either username or user id')
+            )
         return self.cleaned_data
 
     def get_user(self):
@@ -67,4 +73,3 @@ def get_user(self):
             if not isinstance(user, User):
                 continue
             return user
-        raise ValueError('Cannot retrieve user')
diff --git a/disguise/middleware.py b/disguise/middleware.py
index eab7596..a65f49c 100644
--- a/disguise/middleware.py
+++ b/disguise/middleware.py
@@ -1,39 +1,12 @@
 # coding: utf-8
 
-from django.template import RequestContext
-from django.template.loader import render_to_string
-from disguise.forms import DisguiseForm
-import warnings
-
-
-try:
-    from django.utils.encoding import smart_unicode as smart_text
-except ImportError:
-    from django.utils.encoding import smart_text
-
-
-try:
-    from django.contrib.auth import get_user_model
-except ImportError:
-    from django.contrib.auth.models import User
-    get_user_model = lambda: User
-
-
-KEYNAME = 'django_disguise:original_user'
-TAGNAME = '</body>'
-
-
-def replace_insensitive(string, target, replacement):
-    """
-    Similar to string.replace() but is case insensitive
-    Code borrowed from: http://forums.devshed.com/python-programming-11/case-insensitive-string-replace-490921.html
-    """
-    no_case = string.lower()
-    index = no_case.rfind(target.lower())
-    if index >= 0:
-        return string[:index] + replacement + string[index + len(target):]
-    else:  # no results so return the original string
-        return string
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+from disguise.compat import get_user_model
+from disguise.utils import can_disguise
+from disguise.const import KEYNAME
 
 
 class DisguiseMiddleware(object):
@@ -41,18 +14,6 @@ class DisguiseMiddleware(object):
     Disguise user middleware
     """
 
-    def test_disguise(self, request):
-        if KEYNAME in request.session:
-            return True
-
-        if hasattr(request, 'original_user'):
-            return True
-
-        if request.user.has_perm('disguire.can_disguise'):
-            return True
-
-        return False
-
     def get_original_user(self, request):
         if KEYNAME in request.session:
             return get_user_model().objects.get(pk=request.session[KEYNAME])
@@ -60,51 +21,10 @@ def get_original_user(self, request):
 
     def process_request(self, request):
         """
-        Runs during each request
+        Injects the `original_user` attribute into HttpRequest object
         """
-        if not hasattr(request, 'user'):
-            warnings.warn("DisguiseMiddleware must be installed after "
-                          "django.contrib.auth.middleware.AuthenticationMiddleware")
-            return
-
-        if not hasattr(request, 'session'):
-            warnings.warn("DisguiseMiddleware must be installed after "
-                          "django.contrib.sessions.middleware.SessionMiddleware")
-            return
-
         if not request.user.is_authenticated():
             return
-
-        if not self.test_disguise(request):
+        if not can_disguise(request):
             return
-
         request.original_user = self.get_original_user(request)
-
-    def process_response(self, request, response):
-        """
-        Runs during responding
-        """
-        if not request.user.is_authenticated():
-            return response
-
-        if not response.status_code == 200:
-            return response
-
-        if not response.get('content-type', '').startswith('text/html'):
-            return response
-
-        if self.test_disguise(request):
-            # Render HTML code that helps to select disguise
-            html = render_to_string('disguise/form.html', {
-                'form': DisguiseForm(),
-                'original_user': getattr(request, 'original_user', None),
-                'disguise_user': getattr(request, 'user'),
-            }, RequestContext(request))
-
-            # Insert this code before </body>
-            response.content = replace_insensitive(
-                smart_text(response.content),     # Subject
-                TAGNAME,                          # Search
-                smart_text(html + TAGNAME)        # Replace
-            )
-        return response
diff --git a/disguise/models.py b/disguise/models.py
index 884fd8d..fb79cea 100644
--- a/disguise/models.py
+++ b/disguise/models.py
@@ -1,26 +1,31 @@
+# coding: utf-8
+
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
 from django.contrib.auth.models import Permission
 from django.contrib.contenttypes.models import ContentType
 from django.db.models.signals import post_save, post_syncdb
+from django.utils.translation import ugettext_lazy as _
+from disguise.compat import get_user_model
 
 
 def create_perms(sender, **kwargs):
     perms = (
-        ('can_disguise', 'Can disguise'),
+        ('can_disguise', _('Can disguise')),
     )
 
-    # create a content type for the app if it doesn't already exist
-    content_type, created = ContentType.objects.get_or_create(
-        model='',
-        app_label='disguise',
-        defaults={'name': 'disguise'})
+    content_type = ContentType.objects.get_for_model(get_user_model())
+
     for codename, title in perms:
-        # create a permission if it doesn't already exist
-        Permission.objects.get_or_create(codename=codename,
-                                         content_type__pk=content_type.id,
-                                         defaults={
-                                             'name': title,
-                                             'content_type': content_type
-                                         })
+        Permission.objects.get_or_create(
+            codename=codename,
+            content_type=content_type,
+            defaults={
+                'name': title,
+            })
+
 
 post_save.connect(create_perms, Permission)
 post_syncdb.connect(create_perms, sender=__import__('disguise'))
diff --git a/disguise/signals.py b/disguise/signals.py
new file mode 100644
index 0000000..6daf5e2
--- /dev/null
+++ b/disguise/signals.py
@@ -0,0 +1,10 @@
+# coding: utf-8
+
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+from django.core.signals import Signal
+
+disguise_applied = Signal(providing_args=['original_user', 'new_user'])
+disguise_disapplied = Signal(providing_args=['original_user', 'old_user'])
diff --git a/disguise/static/disguise/js/disguise-angular.js b/disguise/static/disguise/js/disguise-angular.js
new file mode 100644
index 0000000..0707895
--- /dev/null
+++ b/disguise/static/disguise/js/disguise-angular.js
@@ -0,0 +1,11 @@
+(function(angular, undefined){
+  "use strict";
+  angular
+    .module("ngDjangoDisguise", [])
+    .directive("disguise", {
+      restrict: "A",
+      scope: true,
+      function($scope, element, attrs, ctrl) {
+      }
+    })
+})(angular)
diff --git a/disguise/static/disguise/js/disguise-jquery.js b/disguise/static/disguise/js/disguise-jquery.js
new file mode 100644
index 0000000..ee1ce49
--- /dev/null
+++ b/disguise/static/disguise/js/disguise-jquery.js
@@ -0,0 +1,5 @@
+(function($, undefined){
+  "use strict";
+  $(document).on('#disguise', 'submit', function(e){
+  });
+})((django ? django.jQuery : false) || jQuery);
diff --git a/disguise/templates/disguise/form.html b/disguise/templates/disguise/form.html
index 061cff5..5bc2eb3 100644
--- a/disguise/templates/disguise/form.html
+++ b/disguise/templates/disguise/form.html
@@ -1,38 +1,46 @@
 {% load i18n %}
-{% load url from future %}
-<div id="disguise" style="display: none">
+{% load url from future %}{# for compatibility with 1.4x #}
+{% load staticfiles %}
+
+{% if can_disguise %}
+  <!-- disguise widget -->
+  <div id="disguise" style="display: none">
     <div class="movable" style="display:none">
-    <p>Current: <b>{{ request.user }} [{{  request.user.pk }}]</b></p>
-    <p>Orignal: <b>{{ request.original_user|default:request.user }} [{{request.original_user.pk}}]</b>{% if request.original_user != request.user %} (<a href="{% url 'disguise_unmask' %}">{% trans "Unmask" %}</a>){% endif %}</p>
-    <form method="post" action="{% url 'disguise_mask' %}">
+      <p>Current: <b>{{ request.user }} [{{  request.user.pk }}]</b></p>
+      <p>Orignal: <b>{{ request.original_user|default:request.user }} [{{request.original_user.pk}}]</b>{% if request.original_user != request.user %} (<a href="{% url 'disguise_unmask' %}">{% trans "Unmask" %}</a>){% endif %}</p>
+      <form method="post" action="{% url 'disguise_mask' %}">
         {% csrf_token %}
         {{ form.as_p }}
         <p><input type="submit" value="{% trans "Disguise" %}" /></p>
-    </form>
+      </form>
     </div>
     <p class="click">{% trans "Disguise user" %}</p>
-</div>
-<script type="text/javascript">
+  </div>
+  <script type="text/javascript">
 (function(){
-    var css = {
-        display: 'block',
-        position: 'fixed',
-        top: 0,
-        right: '30px',
-        width: '200px',
-        border: '#ddd 1px solid',
-        background: '#f5f5f5',
-        opacity: 0.8
-    };
+  var
+    css = {
+      display: 'block',
+      position: 'fixed',
+      top: 0,
+      right: '30px',
+      width: '200px',
+      border: '#ddd 1px solid',
+      background: '#f5f5f5',
+      opacity: 0.8
+    },
 
-    var disguise = function($) {
-        $(function(){
-            var root = $('#disguise');
-            root.css(css).hover(
-                function(){ root.css({ opacity: 1           }); },
-                function(){ root.css({ opacity: css.opacity }); }
-            );
-            root.click(function(e){
+    disguise = function($) {
+      $(function(){
+        var root = $('#disguise');
+        root
+          .css(css)
+          .hover(
+            function(){root.css({opacity: 1});},
+            function(){root.css({opacity: css.opacity});}
+        );
+        root
+          .click(function(e){
                 var tag = e.target.tagName;
                 if (['INPUT', 'A', 'SELECT', 'OPTION'].indexOf(tag) > -1) {
                     e.stopEvent();
@@ -70,4 +78,4 @@
     };
 })();
 </script>
-
+{% endif %}
diff --git a/disguise/templates/disguise/tests/index.html b/disguise/templates/disguise/tests/index.html
index f537e9d..8acfabe 100644
--- a/disguise/templates/disguise/tests/index.html
+++ b/disguise/templates/disguise/tests/index.html
@@ -1 +1,13 @@
-It is a Index document, {{ user.username}}
+{% load disguise_tags %}<!doctype html>
+<html>
+  <head>
+    <title>test app</title>
+    <meta charset="utf-8">
+  </head>
+  <body>
+    <div>
+      <p>It is a Index document, <b>{{ user.username }}</b></p>
+      {% disguise_widget %}
+    </div>
+  </body>
+</html>
diff --git a/disguise/templatetags/__init__.py b/disguise/templatetags/__init__.py
new file mode 100644
index 0000000..1f6693a
--- /dev/null
+++ b/disguise/templatetags/__init__.py
@@ -0,0 +1,6 @@
+# coding: utf-8
+
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
diff --git a/disguise/templatetags/disguise_tags.py b/disguise/templatetags/disguise_tags.py
new file mode 100644
index 0000000..51ced1a
--- /dev/null
+++ b/disguise/templatetags/disguise_tags.py
@@ -0,0 +1,24 @@
+# coding: utf-8
+
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+from django import template
+from disguise.forms import DisguiseForm
+from disguise.utils import can_disguise
+
+
+register = template.Library()
+
+
+@register.inclusion_tag('disguise/form.html', takes_context=True)
+def disguise_widget(context):
+    request = context['request']
+    context.update({
+        'can_disguise': can_disguise(request),
+        'form': DisguiseForm(),
+        'original_user': getattr(request, 'original_user', None),
+        'disguise_user': request.user,
+    })
+    return context
diff --git a/disguise/tests/__init__.py b/disguise/tests/__init__.py
index 9dcd90f..c0f8787 100644
--- a/disguise/tests/__init__.py
+++ b/disguise/tests/__init__.py
@@ -1,138 +1,254 @@
-from django import test
-from django.conf import settings
-from django.conf.urls import patterns
-from django.shortcuts import render
-from django.contrib.auth.models import User
+# coding: utf-8
+
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+from django import test, get_version
+from django.db.models.signals import post_save
+from django.conf.urls import include, url
+from django.core.exceptions import ImproperlyConfigured
 from django.core.urlresolvers import reverse
-from disguise import urls
+from django.contrib.auth.models import Permission
+from django.shortcuts import render
+from disguise.compat import get_user_model
+from disguise.forms import DisguiseForm
+from disguise.signals import disguise_applied, disguise_disapplied
+from disguise.utils import check_env
 
 
-class EnvironmentTest(test.TestCase):
-    def test_request_context_processors(self):
-        """
-        Tests that request context processor is enabled
-        """
-        assert ('django.core.context_processors.request' in
-                settings.TEMPLATE_CONTEXT_PROCESSORS)
+User = get_user_model()
 
-    def test_session_app_enabled(self):
-        """
-        Tests that django session application is installed
-        """
-        assert 'django.contrib.sessions' in settings.INSTALLED_APPS
 
-    def test_middleware_session_enabled(self):
-        """
-        Tests that django session middleware is enabled
-        """
-        assert ('django.contrib.sessions.middleware.SessionMiddleware' in
-                settings.MIDDLEWARE_CLASSES)
+class TestTemplateTag(test.TestCase):
+    url = '/'
 
-    def test_middleware_disguise_enabled(self):
-        """
-        Tests that disguise middleware is enabled
-        """
-        assert ('disguise.middleware.DisguiseMiddleware' in
-                settings.MIDDLEWARE_CLASSES)
+    def setUp(self):
+        self.root = User.objects.create_superuser(username='root',
+                                                  password='root',
+                                                  email='root@example.com')
+        self.user = User.objects.create_user(username='user',
+                                             password='user',
+                                             email='user@example.com')
+        self.client = test.Client()
+        self.client.login(username='root', password='root')
 
-    def test_middleware_disguiseorder(self):
-        """
-        Tests that disguise middleware follows after session middleware
-        """
-        idx = settings.MIDDLEWARE_CLASSES.index
+    def test_anonymous(self):
+        self.client.logout()
+        resp = self.client.get(self.url)
+        self.assertNotContains(resp, '<form ')
 
-        assert (idx('django.contrib.sessions.middleware.SessionMiddleware') <
-                idx('disguise.middleware.DisguiseMiddleware'))
+    def test_regular_user(self):
+        self.client.logout()
+        self.client.login(username='user', password='user')
+        resp = self.client.get(self.url)
+        self.assertNotContains(resp, '<form ')
 
+    def test_superuser(self):
+        resp = self.client.get(self.url)
+        self.assertContains(resp, '<form ')
 
-class DisguiseTest(test.TestCase):
-    urls = 'disguise.tests.urls'
 
-    def patch_urls(self):
-        urls.urlpatterns += patterns(
-            '',
-            (r'^$', lambda request: render(request, 'disguise/tests/index.html')),
-        )
+class TestPermissions(test.TestCase):
+    perm = Permission.objects.filter(codename='can_disguise')
+
+    def test_post_save_permission(self):
+        self.assertFalse(self.perm.exists())
+        post_save.send(sender=Permission)
+        self.perm.get()
+
+
+class TestCheck(test.TestCase):
+    def assertError(self, code):
+        if get_version() >= '1.7':
+            for er in check_env():
+                if er.id == code:
+                    return
+            else:
+                raise AssertionError('{} not happens'.format(code))
+        else:
+            self.assertRaises(ImproperlyConfigured, lambda: check_env())
+
+    def test_all_correctly(self):
+        self.assertFalse(bool(check_env()))
+
+    def test_no_sessions_app(self):
+        with self.settings(INSTALLED_APPS=[]):
+            self.assertError('disguise.E001')
+
+    def test_no_context_processors(self):
+        with self.settings(TEMPLATE_CONTEXT_PROCESSORS=[]):
+            self.assertError('disguise.E002')
+
+    def test_no_sessions_middleware(self):
+        with self.settings(MIDDLEWARE_CLASSES=[]):
+            self.assertError('disguise.E003')
+
+    def test_no_disguise_middleware(self):
+        with self.settings(MIDDLEWARE_CLASSES=[]):
+            self.assertError('disguise.E004')
+
+    def test_middleware_order(self):
+        MIDDLEWARE_CLASSES = [
+            'disguise.middleware.DisguiseMiddleware'
+            'django.contrib.sessions.middleware.SessionMiddeware'
+        ]
+        with self.settings(MIDDLEWARE_CLASSES=MIDDLEWARE_CLASSES):
+            self.assertError('disguise.E005')
+
+
+class TestForm(test.TestCase):
+    def setUp(self):
+        self.user = User.objects.create(username='user', password='user',
+                                        email='user@example.com')
+
+    def test_form_invalid_everything(self):
+        form = DisguiseForm({})
+        self.assertFalse(form.is_valid())
+        self.assertIn('__all__', form.errors)
+
+    def test_form_invalid_when_wrong_username(self):
+        form = DisguiseForm({'username': self.user.username + '_not'})
+        self.assertFalse(form.is_valid())
+        self.assertIn('username', form.errors)
+
+    def test_form_invalid_when_wrong_user_id(self):
+        form = DisguiseForm({'user_id': 31337})
+        self.assertFalse(form.is_valid())
+        self.assertIn('user_id', form.errors)
+
+    def test_form_valid_when_correct_username(self):
+        form = DisguiseForm({'username': self.user.username})
+        self.assertTrue(form.is_valid())
+
+    def test_form_valid_when_correct_user_id(self):
+        form = DisguiseForm({'user_id': self.user.pk})
+        self.assertTrue(form.is_valid())
+
+
+class DisguiseTest(test.TestCase):
+    urls = 'disguise.tests'
 
     def setUp(self):
-        self.patch_urls()
-        self.john = User.objects.create_superuser(username='john',
-                                                  password='smith',
-                                                  email='john@smith.com')
-        self.jane = User.objects.create_user(username='jane',
-                                             password='smith',
-                                             email='jane@smith.com')
+        self.mask_url = reverse('disguise_mask')
+        self.unmask_url = reverse('disguise_unmask')
+        self.root = User.objects.create_superuser(
+            username='root',
+            password='root',
+            email='root@example.com'
+        )
+        self.user = User.objects.create_user(
+            username='user',
+            password='user',
+            email='root@example.com'
+        )
         self.client = test.Client()
-        self.url_mask = reverse('disguise_mask')
-        self.url_unmask = reverse('disguise_unmask')
+        self.client.login(username='root', password='root')
+
+    def mask_request(self, username=None, user_id=None, follow=False):
+        data = {}
+        if user_id:
+            data.update(user_id=user_id)
+        if username:
+            data.update(username=username)
+        return self.client.post(self.mask_url, data, follow=follow)
+
+    def unmask_request(self, follow=False):
+        return self.client.get(self.unmask_url, follow=follow)
+
+    def test_anonymous_access(self):
+        self.client.logout()
+        resp = self.mask_request(username='user')
+        self.assertEquals(302, resp.status_code)
+
+    def test_non_privilegied_access(self):
+        self.client.logout()
+        self.client.login(username='user', password='user')
+        resp = self.mask_request(username='root')
+        self.assertEquals(302, resp.status_code)
 
     def test_mask_myself(self):
         """
         Tests if superuser can disguise to regular user by username
         """
-        # Login as superuser
-        self.client.login(username='john', password='smith')
-
-        # Disguise to regular user
-        resp = self.client.post(self.url_mask, data={'username': 'jane'}, follow=True)
-        self.assertEquals(self.jane, resp.context['request'].user)
-        self.assertEquals(self.john, resp.context['request'].original_user)
+        resp = self.mask_request(username='user', follow=True)
+        self.assertEquals(200, resp.status_code)
+        self.assertEquals(self.user, resp.context['request'].user)
+        self.assertEquals(self.root, resp.context['request'].original_user)
+        self.assertContains(resp, '<form ')
 
         # Disguise to superuser again
-        resp = self.client.post(self.url_mask, data={'username': 'john'}, follow=True)
-        self.assertEquals(self.john, resp.context['request'].original_user)
-        self.assertEquals(self.john, resp.context['request'].user)
+        resp = self.mask_request(username='root', follow=True)
+        self.assertEquals(200, resp.status_code)
+        self.assertEquals(self.root, resp.context['request'].original_user)
+        self.assertEquals(self.root, resp.context['request'].user)
+        self.assertContains(resp, '<form ')
 
     def test_unmask(self):
-        """
-        Tests if superuser can disguise to regular user by username
-        """
-        self.client.login(username='john', password='smith')
-        resp = self.client.post(self.url_mask, data={'username': 'jane'}, follow=True)
-        resp = self.client.get(self.url_unmask, follow=True)
-        self.assertEquals(self.john, resp.context['request'].user)
+        self.mask_request(username='user', follow=True)
+        resp = self.unmask_request(follow=True)
+        self.assertEquals(self.root, resp.context['request'].user)
 
-    def test_by_username(self):
+    def test_disguise_by_username(self):
         """
         Tests if superuser can disguise to regular user by username
         """
-        self.client.login(username='john', password='smith')
-        resp = self.client.post(self.url_mask, data={'username': 'jane'}, follow=True)
-        self.assertEquals(self.jane, resp.context['request'].user)
+        resp = self.mask_request(username=self.user, follow=True)
+        self.assertEquals(self.user, resp.context['request'].user)
 
-    def test_by_user_id(self):
+    def test_disguise_by_user_id(self):
         """
         Tests if superuser can disguise to regular user by user id
         """
-        self.client.login(username='john', password='smith')
-        resp = self.client.post(self.url_mask, data={'user_id': '2'}, follow=True)
-        self.assertEquals(self.jane, resp.context['request'].user)
+        resp = self.mask_request(user_id=self.user.pk, follow=True)
+        self.assertEquals(self.user, resp.context['request'].user)
 
-    def test_update_last_login(self):
-        """
-        Tests that last login time for user is changed
-        """
-        self.client.login(username='john', password='smith')
-        was = self.jane.last_login
-        resp = self.client.post(self.url_mask,
-                                data={'user_id': '2',
-                                      'update_last_login': '1'},
-                                follow=True)
-        self.assertNotEquals(was, resp.context['request'].user.last_login)
-
-    def test_not_update_last_login(self):
-        """
-        Tests that last login time for user isn't changed
-        """
-        self.client.login(username='john', password='smith')
-        was = self.jane.last_login
-        resp = self.client.post(self.url_mask, data={'user_id': '2'}, follow=True)
-        self.assertTrue(was < resp.context['request'].user.last_login)
+    def test_disguise_applied_signal(self):
+        self._entered = False
 
-    def test_permission_required(self):
-        """
-        Tests that regular user can't disguise
-        """
-        self.client.login(username='jane', password='smith')
-        resp = self.client.post(self.url_mask, data={'username': 'john'}, follow=True)
-        self.assertEquals(self.jane, resp.context['request'].user)
+        def handler(**kwargs):
+            original_user = kwargs['original_user']
+            new_user = kwargs['new_user']
+
+            self.assertEquals(original_user, self.root)
+            self.assertEquals(new_user, self.user)
+            self._entered = True
+
+        disguise_applied.connect(handler, sender=User, dispatch_uid='test')
+
+        self.mask_request(username=self.user, follow=True)
+        self.assertTrue(self._entered)
+
+        disguise_applied.disconnect(handler, sender=User, dispatch_uid='test')
+        del self._entered
+
+    def test_disguise_disapplied_signal(self):
+        self._entered = False
+
+        def handler(**kwargs):
+            original_user = kwargs['original_user']
+            old_user = kwargs['old_user']
+
+            self.assertEquals(original_user, self.root)
+            self.assertEquals(old_user, self.user)
+            self._entered = True
+
+        disguise_disapplied.connect(handler, sender=User,
+                                    dispatch_uid='test')
+        self.mask_request(username=self.user, follow=True)
+        self.unmask_request(follow=True)
+        self.assertTrue(self._entered)
+        disguise_disapplied.disconnect(handler, sender=User,
+                                       dispatch_uid='test')
+        del self._entered
+
+
+def index(request):
+    return render(request, 'disguise/tests/index.html')
+
+
+urlpatterns = [
+    url(r'^disguise/', include('disguise.urls')),
+    url(r'^accounts/login/$', index),
+    url(r'^$', index),
+]
diff --git a/disguise/tests/urls.py b/disguise/tests/urls.py
deleted file mode 100644
index 27a1206..0000000
--- a/disguise/tests/urls.py
+++ /dev/null
@@ -1,18 +0,0 @@
-# coding: utf-8
-
-from django.conf.urls import include, url, patterns    # NOQA
-from django.http import HttpResponse
-from django.template import Context, Template
-
-
-def index(request):
-    template = Template("")
-    context = Context({'request': request, 'user': request.user})
-    return HttpResponse(template.render(context))
-
-
-urlpatterns = [
-    url('^disguise/', include('disguise.urls')),
-    url('^accounts/login/$', index),
-    url('^$', index),
-]
diff --git a/disguise/urls.py b/disguise/urls.py
index 5b7e955..3543557 100644
--- a/disguise/urls.py
+++ b/disguise/urls.py
@@ -1,10 +1,10 @@
 # coding: utf-8
 
 from django.conf.urls import url
-from disguise.views import mask, unmask
+from disguise.views import MaskView, UnmaskView
 
 
 urlpatterns = [
-    url('^$', mask, name='disguise_mask'),
-    url('^unmask/$', unmask, name='disguise_unmask'),
+    url(r'^$', MaskView.as_view(), name='disguise_mask'),
+    url(r'^unmask/$', UnmaskView.as_view(), name='disguise_unmask'),
 ]
diff --git a/disguise/utils.py b/disguise/utils.py
new file mode 100644
index 0000000..1c2c7f8
--- /dev/null
+++ b/disguise/utils.py
@@ -0,0 +1,104 @@
+# coding: utf-8
+
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+from django.conf import settings
+from disguise.const import KEYNAME
+from disguise.compat import checks
+
+
+def check_env():
+    idx = settings.MIDDLEWARE_CLASSES.index
+
+    # Checks if `django.contrib.sessions` application installed
+    sessions_app_installed = ('django.contrib.sessions' in
+                              settings.INSTALLED_APPS)
+
+    # Checks if `django.core.context_processors.request` added
+    # into TEMPLATE_CONTEXT_PROCESSORS tuple
+    context_processors = ('django.core.context_processors.request' in
+                          settings.TEMPLATE_CONTEXT_PROCESSORS)
+
+    # Checks if sessions middleware is added into MIDDLEWARE_CLASSES
+    sessions_middleware_installed = (
+        'django.contrib.sessions.middleware.SessionMiddleware'
+        in settings.MIDDLEWARE_CLASSES
+    )
+
+    # Checks if disguise middleware is added into MIDDLEWARE_CLASSES
+    disguise_middleware_installed = ('disguise.middleware.DisguiseMiddleware'
+                                     in settings.MIDDLEWARE_CLASSES)
+
+    # Checks if sessions middleware installed before disguise one
+    try:
+        middleware_order = (
+            idx('django.contrib.sessions.middleware.SessionMiddleware') <
+            idx('disguise.middleware.DisguiseMiddleware')
+        )
+    except ValueError:
+        middleware_order = False
+
+    errors = []
+
+    if not sessions_app_installed:
+        errors.append(
+            checks.Error(
+                'Django sessions app is *not* installed',
+                id='disguise.E001',
+                hint=('Add the `django.contrib.sessions` into '
+                      'your INSTALLED_APPS setting')
+            )
+        )
+    if not context_processors:
+        errors.append(
+            checks.Error(
+                'There is no `request` variable in template context',
+                id='disguise.E002',
+                hint=('Add the django.core.context_processors.request into '
+                      'your TEMPLATE_CONTEXT_PROCESSORS setting')
+            )
+        )
+    if not sessions_middleware_installed:
+        errors.append(
+            checks.Error(
+                'Session middleware is *NOT* installed',
+                id='disguise.E003',
+                hint=('Add `django.contrib.sessions.middleware.Session'
+                      'Middleware` into your MIDDLEWARE_CLASSES setting')
+            )
+        )
+    if not disguise_middleware_installed:
+        errors.append(
+            checks.Error(
+                'Disguise middleware is *NOT* installed',
+                id='disguise.E004',
+                hint=('Add `disguise.middleware.DisguiseMiddleware` '
+                      'into your MIDDLEWARE_CLASSES setting')
+            )
+        )
+    if not middleware_order:
+        errors.append(
+            checks.Error(
+                'Session middleware must be installed before disguise one',
+                id='disguise.E005',
+                hint=('Swap the disguise.middleware.DisguiseMiddleware with '
+                      'django.contrib.sessions.middleware.SessionMiddeware')
+            )
+        )
+
+    return errors
+
+
+def can_disguise(request):
+    if KEYNAME in request.session:
+        return True
+
+    if hasattr(request, 'original_user'):
+        return True
+
+    if request.user.has_perm('disguise.can_disguise'):
+        return True
+
+    return False
diff --git a/disguise/views.py b/disguise/views.py
index f4acbe6..e751b7c 100644
--- a/disguise/views.py
+++ b/disguise/views.py
@@ -1,68 +1,73 @@
+# coding: utf-8
+
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
 from django.contrib.auth.views import redirect_to_login
 from django.shortcuts import redirect
-from django.contrib.auth import login, SESSION_KEY, BACKEND_SESSION_KEY
+from django.contrib.auth import login
+from django.views.generic import View, FormView
 from disguise.forms import DisguiseForm
-from disguise.middleware import KEYNAME
-import datetime
-
-
-def disguise_permission_required(view):
-    def guard(request):
-        if not getattr(request, 'original_user', None):
-            if not request.user.has_perm('disguise.can_disguise'):
-                return redirect_to_login(request)
-            return redirect_to_login(request.get_full_path())
-        return view(request)
-    return guard
-
-
-@disguise_permission_required
-def mask(request):
-    """
-    Disguise
-    """
-    referer = request.META.get('HTTP_REFERER', '/')
-    form = DisguiseForm(request.POST or None)
-
-    if form.is_valid():
-        # if not hasattr(request,'original_user') or request.original_user is None:
-        if KEYNAME not in request.session:
-            request.original_user = request.user
-            request.session[KEYNAME] = request.original_user.pk
+from disguise.const import KEYNAME, SESSION_KEY, BACKEND_SESSION_KEY, BACKEND
+from disguise.utils import can_disguise
+from disguise.signals import disguise_applied, disguise_disapplied
 
-        # Okay, security checks complete. Log the user in.
-        new_user = form.get_user()
-        new_user.backend = 'django.contrib.auth.backends.ModelBackend'
 
-        # Change current user
-        request.session[SESSION_KEY] = new_user.id
-        request.session[BACKEND_SESSION_KEY] = new_user.backend
+class DisguiseMixin(object):
+    def dispatch(self, request, *args, **kwargs):
+        if not can_disguise(request):
+            return redirect_to_login(request)
+        return super(DisguiseMixin, self).dispatch(request, *args, **kwargs)
 
-        if hasattr(request, 'user'):
-            request.user = new_user
+    def get_http_referer(self):
+        return self.request.META.get('HTTP_REFERER', '/')
 
-        if request.session.test_cookie_worked():
-            request.session.delete_test_cookie()
+    def test_cookie(self):
+        if self.request.session.test_cookie_worked():
+            self.request.session.delete_test_cookie()
 
-        if 'update_last_login' in form.cleaned_data:
-            request.user.last_login = datetime.datetime.now()
-            request.user.save()
 
-    return redirect(referer)
+class MaskView(DisguiseMixin, FormView):
+    form_class = DisguiseForm
 
+    def switch_user(self, user):
+        self.request.session[SESSION_KEY] = user.id
+        self.request.session[BACKEND_SESSION_KEY] = user.backend
+        self.request.user = user
 
-@disguise_permission_required
-def unmask(request):
-    referer = request.META.get('HTTP_REFERER', '/')
+    def form_valid(self, form):
+        request = self.request
+        if KEYNAME not in request.session:
+            request.original_user = request.user
+            request.session[KEYNAME] = request.original_user.pk
 
-    if hasattr(request, 'original_user'):
         # Okay, security checks complete. Log the user in.
-        new_user = request.original_user
-        new_user.backend = 'django.contrib.auth.backends.ModelBackend'
-
-        login(request, new_user)
-
-        if request.session.test_cookie_worked():
-            request.session.delete_test_cookie()
+        new_user = form.get_user()
+        new_user.backend = BACKEND
 
-    return redirect(referer)
+        # Change current user
+        self.switch_user(new_user)
+        self.test_cookie()
+
+        disguise_applied.send(sender=new_user.__class__,
+                              original_user=request.original_user,
+                              new_user=new_user)
+        return redirect(self.get_http_referer())
+
+
+class UnmaskView(DisguiseMixin, View):
+    def get(self, request, *args, **kwargs):
+        if hasattr(request, 'original_user'):
+            # Okay, security checks complete. Log the user in.
+            old_user = request.user
+            new_user = request.original_user
+            new_user.backend = BACKEND
+
+            login(request, new_user)
+
+            disguise_disapplied.send(sender=new_user.__class__,
+                                     original_user=request.original_user,
+                                     old_user=old_user)
+        self.test_cookie()
+        return redirect(self.get_http_referer())
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000..b8a1655
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,3 @@
+[bdist_wheel]
+universal = 1
+
diff --git a/setup.py b/setup.py
index 985cb47..bd1ab6a 100755
--- a/setup.py
+++ b/setup.py
@@ -5,29 +5,35 @@
 import os
 
 
-version = '0.0.4'
+version = '0.1.0'
 
 
 CLASSIFIERS = [
-    'Development Status :: 4 - Beta',
     'Environment :: Web Environment',
     'Intended Audience :: Developers',
     'License :: OSI Approved :: BSD License',
     'Operating System :: OS Independent',
     'Programming Language :: Python',
+    'Programming Language :: Python :: 2.7',
+    'Programming Language :: Python :: 3.3',
+    'Programming Language :: Python :: 3.4',
     'Framework :: Django'
 ]
 
 
+def long_description():
+    with open(os.path.join(os.path.dirname(__file__), 'README.rst')) as fp:
+        return fp.read()
+
 setup(
     name='django-disguise',
-    author='marazmiki',
+    author='Mikhail Porokhovnichenko',
     version=version,
     author_email='marazmiki@gmail.com',
-    url='http://pypi.python.org/pypi/django-disguise',
-    download_url='http://bitbucket.org/marazmiki/django-disguise/get/tip.zip',
-    description='This django application allows superuser to "disguise" into any user',
-    long_description=open(os.path.join(os.path.dirname(__file__), 'README.rst')).read(),
+    url='https://github.com/marazmiki/django-disguise',
+    description=('This django application allows superuser to '
+                 '"disguise" into any user'),
+    long_description=long_description(),
     license='MIT license',
     platforms=['OS Independent'],
     classifiers=CLASSIFIERS,
diff --git a/tests.py b/tests.py
index 8df052e..6d4cfe6 100755
--- a/tests.py
+++ b/tests.py
@@ -1,9 +1,12 @@
 #!/usr/bin/env python
 # coding: utf-8
 
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
 from django import get_version
 from django.conf import settings
-
 import sys
 import os
 
@@ -12,11 +15,12 @@
 
 
 settings.configure(
-    ROOT_URLCONF='disguise.tests.urls',
+    ROOT_URLCONF='disguise.tests',
     INSTALLED_APPS=(
         'django.contrib.contenttypes',
         'django.contrib.auth',
         'django.contrib.sessions',
+        'django.contrib.staticfiles',
         'disguise',
     ),
     TEMPLATE_CONTEXT_PROCESSORS = (