cherrypy-foundation 1.0.0a1__py3-none-any.whl → 1.0.0a2__py3-none-any.whl

cherrypy_foundation/tools/i18n.py

@@ -105,6 +105,15 @@ from babel.support import LazyProxy, NullTranslations, Translations
 _current = threading.local()
 
 
+def _get_config(key, default=None):
+    """
+    Lookup configuration from request, if available. Fallback to global config.
+    """
+    if getattr(cherrypy, 'request') and getattr(cherrypy.request, 'config') and key in cherrypy.request.config:
+        return cherrypy.request.config[key]
+    return cherrypy.config.get(key, default)
+
+
 @contextmanager
 def preferred_lang(lang):
     """
@@ -199,7 +208,7 @@ def get_timezone():
         return tzinfo
     # Otherwise search for a valid timezone.
     tzinfo = None
-    default_timezone = cherrypy.config.get('tools.i18n.default_timezone')
+    default_timezone = _get_config('tools.i18n.default_timezone')
     preferred_timezone = getattr(_current, 'preferred_timezone', [default_timezone])
     for timezone in preferred_timezone:
         try:
@@ -226,10 +235,10 @@ def get_translation():
     # Otherwise, we need to search the translation.
     # `preferred_lang` should always has a sane value within a cherrypy request because of hooks
     # But we also need to support calls outside cherrypy.
-    default = cherrypy.config.get('tools.i18n.default')
+    default = _get_config('tools.i18n.default')
     preferred_lang = getattr(_current, 'preferred_lang', [default])
-    mo_dir = cherrypy.config.get('tools.i18n.mo_dir')
-    domain = cherrypy.config.get('tools.i18n.domain')
+    mo_dir = _get_config('tools.i18n.mo_dir')
+    domain = _get_config('tools.i18n.domain')
     trans = _search_translation(mo_dir, domain, *preferred_lang)
     if trans is None:
         trans = NullTranslations()
@@ -242,8 +251,8 @@ def list_available_locales():
     """
     Return a list of available translations.
     """
-    mo_dir = cherrypy.config.get('tools.i18n.mo_dir', False)
-    domain = cherrypy.config.get('tools.i18n.domain')
+    mo_dir = _get_config('tools.i18n.mo_dir', False)
+    domain = _get_config('tools.i18n.domain')
     if not mo_dir:
         return
     for lang in os.listdir(mo_dir):

cherrypy_foundation/tools/jinja2.py

@@ -15,6 +15,7 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 import importlib
+import logging
 import time
 
 import cherrypy
@@ -51,15 +52,15 @@ class Jinja2Tool(cherrypy.Tool):
 
         def wrap(*args, **kwargs):
             # Call original handler
-            vars = self.oldhandler(*args, **kwargs)
+            context = self.oldhandler(*args, **kwargs)
             # Render template.
-            return self.render_request(env=env, template=template, vars=vars, extra_processor=extra_processor)
+            return self.render_request(env=env, template=template, context=context, extra_processor=extra_processor)
 
         request = cherrypy.serving.request
         if request.handler is not None:
             # Replace request.handler with self
             if debug:
-                cherrypy.log('Replacing request.handler', 'TOOLS.JINJA2')
+                cherrypy.log('replacing request handler', context='TOOLS.JINJA2', severity=logging.DEBUG)
             self.oldhandler = request.handler
             request.handler = wrap
 
@@ -79,12 +80,14 @@ class Jinja2Tool(cherrypy.Tool):
 
         # Enable translation if available
         if hasattr(cherrypy.tools, 'i18n'):
-            from .i18n import format_datetime, get_language_name, ugettext, ungettext
+            from .i18n import format_date, format_datetime, get_language_name, get_translation, ugettext, ungettext
 
             env.add_extension('jinja2.ext.i18n')
             env.install_gettext_callables(ugettext, ungettext, newstyle=True)
+            env.filters['format_date'] = format_date
             env.filters['format_datetime'] = format_datetime
             env.globals['get_language_name'] = get_language_name
+            env.globals['get_translation'] = get_translation
 
         # Update globals, filters and tests
         env.globals.update(globals)
@@ -104,7 +107,7 @@ class Jinja2Tool(cherrypy.Tool):
 
         return env
 
-    def render_request(self, template, vars={}, env=_UNDEFINED, extra_processor=_UNDEFINED):
+    def render_request(self, template, context={}, env=_UNDEFINED, extra_processor=_UNDEFINED):
         """
         Render template for a given cherrypy request.
         """
@@ -114,24 +117,24 @@ class Jinja2Tool(cherrypy.Tool):
         if extra_processor is _UNDEFINED:
             extra_processor = request.config.get('tools.jinja2.extra_processor')
         # Execute extra processor if defined.
-        all_vars = {}
+        new_context = {}
         if extra_processor:
-            all_vars.update(extra_processor())
-        all_vars.update(vars)
+            new_context.update(extra_processor())
+        new_context.update(context)
         # Render templates
-        return self.render(env=env, template=template, vars=all_vars)
+        return self.render(env=env, template=template, context=new_context)
 
-    def render(self, env, template, vars={}):
+    def render(self, env, template, context={}):
         """
         Lower level function used to render a template using the given jinja2 environment, template(s) and variable context.
         """
         # Get the right templates
         if isinstance(template, (list, tuple)):
-            names = [t.format(**vars) for t in template]
+            names = [t.format(**context) for t in template]
             tmpl = env.select_template(names)
         else:
             tmpl = env.get_template(template)
-        out = tmpl.render(vars)
+        out = tmpl.render(context)
 
         # With JinjaX > 0.60 render explicitly here.
         if 'catalog' in env.globals and getattr(env.globals['catalog'], '_emit_assets_later', False):

cherrypy_foundation/tools/ratelimit.py

@@ -146,6 +146,8 @@ class FileRateLimit(_DataStore):
 
 
 class Ratelimit(cherrypy.Tool):
+    CONTEXT = 'TOOLS.RATELIMIT'
+
     def __init__(self, priority=60):
         super().__init__('before_handler', self.check_ratelimit, 'ratelimit', priority)
 
@@ -182,10 +184,7 @@ class Ratelimit(cherrypy.Tool):
         request = cherrypy.request
         if methods is not None and request.method not in methods:
             if debug:
-                cherrypy.log(
-                    'skip rate limit for HTTP method %s' % (request.method,),
-                    'TOOLS.RATELIMIT',
-                )
+                cherrypy.log(f'skip rate limit for HTTP method {request.method}', context=self.CONTEXT)
             return
 
         # If datastore is not pass as configuration, create it for the first time.
@@ -213,10 +212,7 @@ class Ratelimit(cherrypy.Tool):
         # Get hits count using datastore.
         hits, timeout = datastore.get_and_increment(token, delay, hit)
         if debug:
-            cherrypy.log(
-                'check and increase rate limit for scope %s, limit %s, hits %s' % (token, limit, hits),
-                'TOOLS.RATELIMIT',
-            )
+            cherrypy.log(f'check and increase limit token={token} limit={limit} hits={hits}', context=self.CONTEXT)
 
         # Verify user has not exceeded rate limit
         remaining = max(0, limit - hits)
@@ -227,7 +223,7 @@ class Ratelimit(cherrypy.Tool):
         cherrypy.response.headers['X-RateLimit-Reset'] = str(timeout)
 
         if limit < hits:  # block only after 'limit' successful requests
-            cherrypy.log('ratelimit access to `%s`' % request.path_info, 'TOOLS.RATELIMIT')
+            cherrypy.log(f'block access to path_info={request.path_info}', context=self.CONTEXT)
             if logout:
                 if hasattr(cherrypy.serving, 'session'):
                     cherrypy.serving.session.clear()

cherrypy_foundation/tools/secure_headers.py

@@ -15,13 +15,9 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 import http.cookies
-import logging
 
 import cherrypy
 
-# Define the logger
-logger = logging.getLogger(__name__)
-
 DEFAULT_CSP = {
     'default-src': 'self',
     'style-src': ('self', 'unsafe-inline'),

cherrypy_foundation/tools/tests/components/Button.jinja

@@ -0,0 +1,2 @@
+{# def label, link #}
+<a {{ attrs.render(class='btn btn-primary', href=link) }}>{{ label }}</a>

cherrypy_foundation/tools/tests/templates/test_jinja2.html

@@ -0,0 +1,10 @@
+<html>
+    <head>
+        <title>test-jinja2</title>
+    </head>
+    <body>
+        var1: {{ var1 }}<br/>
+        var2: {{ var2 }}<br/>
+        const1: {{ const1 }}<br/>
+    </body>
+</html>

cherrypy_foundation/tools/tests/templates/test_jinja2_i18n.html

@@ -0,0 +1,11 @@
+<html lang="{{ get_translation().locale }}">
+    <head>
+        <title>test-jinja2</title>
+    </head>
+    <body>
+        {{ get_language_name(get_translation().locale) }}<br/>
+        {% trans %}Some text to translate{% endtrans %}<br/>
+        {{ my_datetime | format_datetime(format='full') }}<br/>
+        {{ my_date | format_date(format='full') }}
+    </body>
+</html>

cherrypy_foundation/tools/tests/templates/test_jinjax.html

@@ -0,0 +1,8 @@
+<html>
+    <head>
+        <title>test-jinja2</title>
+    </head>
+    <body>
+        <Button link="http://example.com" label="foo" />
+    </body>
+</html>

cherrypy_foundation/tools/tests/test_auth.py

@@ -83,7 +83,7 @@ class AuthManagerTest(helper.CPWebCase):
     def test_auth_login(self):
         # Given unauthenticated user
         # When posting valid login
-        self.getPage('/login/', method='POST', body=urlencode([('username', 'myuser'), ('password', 'changeme')]))
+        self.getPage('/login/', method='POST', body=urlencode({'username': 'myuser', 'password': 'changeme'}))
         # Then user is redirect to index.
         self.assertStatus(303)
         self.assertHeaderItemValue('Location', f'http://{self.HOST}:{self.PORT}/')

cherrypy_foundation/tools/tests/test_auth_mfa.py

@@ -0,0 +1,367 @@
+# CherryPy
+# Copyright (C) 2025 IKUS Software
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+
+import datetime
+from collections import namedtuple
+from urllib.parse import urlencode
+
+import cherrypy
+from cherrypy.lib.sessions import RamSession
+from cherrypy.test import helper
+
+from ..auth import AUTH_LAST_PASSWORD_AT
+from ..auth_mfa import (
+    MFA_CODE_TIME,
+    MFA_DEFAULT_CODE_TIMEOUT,
+    MFA_DEFAULT_TRUST_DURATION,
+    MFA_TRUSTED_IP_LIST,
+    MFA_USER_KEY,
+    MFA_VERIFICATION_TIME,
+)
+from ..sessions_timeout import SESSION_PERSISTENT
+
+User = namedtuple('User', 'id,username,password,email,mfa', defaults=[False])
+
+users = {
+    User(2, 'myuser', 'changeme', 'myuser@example.com', False),
+    User(3, 'mfauser', 'changeme', 'mfauser@example.com', True),
+    User(4, 'noemail', 'changeme', '', True),
+}
+
+
+def checkpassword(username, password):
+    for u in users:
+        if u.username == username and u.password == password:
+            return True
+    return False
+
+
+def user_lookup_func(login, user_info):
+    for u in users:
+        if u.username == login:
+            return u.id, u
+    return None
+
+
+def user_from_key_func(userkey):
+    for u in users:
+        if u.id == userkey:
+            return u
+    return None
+
+
+@cherrypy.tools.sessions()
+@cherrypy.tools.auth(
+    user_lookup_func=user_lookup_func,
+    user_from_key_func=user_from_key_func,
+    checkpassword=checkpassword,
+)
+@cherrypy.tools.auth_mfa(
+    mfa_enabled=lambda: hasattr(cherrypy.serving.request, 'currentuser') and cherrypy.request.currentuser.mfa
+)
+class Root:
+
+    @cherrypy.expose
+    def index(self):
+        return "OK"
+
+    @cherrypy.expose()
+    def login(self, username=None, password=None):
+        if cherrypy.serving.request.method == 'POST' and username and password:
+            userobj = cherrypy.tools.auth.login_with_credentials(username, password)
+            if userobj:
+                raise cherrypy.tools.auth.redirect_to_original_url()
+            else:
+                return "invalid credentials"
+        return "login"
+
+    @cherrypy.expose()
+    def mfa(self, code=None, resend_code=None, persistent=False):
+        html = "mfa\n"
+        if cherrypy.serving.request.method == 'POST' and code:
+            if cherrypy.tools.auth_mfa.verify_code(code=code, persistent=persistent):
+                raise cherrypy.tools.auth.redirect_to_original_url()
+            else:
+                html += "<p>invalid verification code</p>\n"
+        # Send verification code if previous code expired.
+        # Or when requested by user.
+        if (resend_code and cherrypy.serving.request.method == 'POST') or cherrypy.tools.auth_mfa.is_code_expired():
+            code = cherrypy.tools.auth_mfa.generate_code()
+            # Here the code should be send by email, SMS or any other means.
+            # For our test we store it in the session.
+            cherrypy.serving.session['code'] = code
+            html += "<p>new verification code sent to your email</p>\n"
+        return html
+
+
+class AuthManagerMfaTest(helper.CPWebCase):
+    interactive = False
+    # Authenticated by default.
+    login = True
+
+    @classmethod
+    def setup_server(cls):
+        cherrypy.tree.mount(Root(), '/')
+
+    def getPage(self, *args, **kwargs):
+        """
+        This implementation keep track of session cookies.
+        """
+        headers = kwargs.pop('headers', [])
+        if hasattr(self, 'cookies') and self.cookies:
+            headers.extend(self.cookies)
+        return helper.CPWebCase.getPage(self, *args, headers=headers, **kwargs)
+
+    def _login(self, username, password):
+        self.getPage('/login/', method='POST', body=urlencode({'username': username, 'password': password}))
+        self.assertStatus(303)
+        self.assertHeaderItemValue('Location', f'http://{self.HOST}:{self.PORT}/')
+
+    @property
+    def _session_id(self):
+        if hasattr(self, 'cookies') and self.cookies:
+            for unused, value in self.cookies:
+                for part in value.split(';'):
+                    key, unused, value = part.partition('=')
+                    if key == 'session_id':
+                        return value
+
+    def _get_code(self):
+        # Query MFA page to generate a code
+        self.getPage("/mfa/")
+        self.assertStatus(200)
+        self.assertInBody("new verification code sent to your email")
+        # Extract code from user session for testing only.
+        session = RamSession.cache[self._session_id][0]
+        return session['code']
+
+    def test_get_without_login(self):
+        # Given the user is not authenticated.
+        # When requesting /mfa/
+        self.getPage("/mfa/")
+        # Then user is redirected to /login/
+        self.assertStatus(303)
+        self.assertHeaderItemValue('Location', f'http://{self.HOST}:{self.PORT}/login/')
+
+    def test_get_with_mfa_disabled(self):
+        # Given an authenticated user with MFA Disable
+        self._login('myuser', 'changeme')
+        # When requesting /mfa/ page
+        self.getPage("/mfa/")
+        # Then user is redirected to root page
+        self.assertStatus(303)
+        self.assertHeaderItemValue('Location', f'http://{self.HOST}:{self.PORT}/')
+        # Then index is enabled.
+        self.getPage("/")
+        self.assertStatus(200)
+        self.assertInBody('OK')
+
+    def test_get_with_trusted(self):
+        # Given an authenticated user with MFA Disable
+        self._login('mfauser', 'changeme')
+        # Given an authenticated user with MFA enabled and already verified
+        session = RamSession.cache[self._session_id][0]
+        session[MFA_USER_KEY] = 3
+        session[MFA_VERIFICATION_TIME] = datetime.datetime.now()
+        session[MFA_TRUSTED_IP_LIST] = ['127.0.0.1']
+
+        # When requesting /mfa/ page when we are already trusted
+        self.getPage("/mfa/")
+        # Then user is redirected to root page
+        self.assertStatus(303)
+        self.assertHeaderItemValue('Location', f'http://{self.HOST}:{self.PORT}/')
+
+    def test_get_with_trusted_expired(self):
+        # Given an authenticated user with MFA enabled and already verified
+        self._login('mfauser', 'changeme')
+        session = RamSession.cache[self._session_id][0]
+        session[MFA_USER_KEY] = 3
+        session[MFA_VERIFICATION_TIME] = datetime.datetime.now() - datetime.timedelta(minutes=60)
+
+        # When requesting /mfa/ page
+        self.getPage("/mfa/")
+        self.assertStatus(200)
+        # Then a verification code is send to the user
+        self.assertInBody("new verification code sent to your email")
+
+    def test_get_with_trusted_different_ip(self):
+        # Given an authenticated user with MFA enabled and already verified
+        self._login('mfauser', 'changeme')
+        session = RamSession.cache[self._session_id][0]
+        session[MFA_USER_KEY] = 3
+        session[MFA_VERIFICATION_TIME] = datetime.datetime.now()
+
+        # When requesting /mfa/ page from a different ip
+        self.getPage("/mfa/", headers=[('X-Forwarded-For', '10.255.14.23')])
+        self.assertStatus(200)
+        # Then a verification code is send to the user
+        self.assertInBody("new verification code sent to your email")
+
+    def test_get_without_verified(self):
+        # Given an authenticated user With MFA enabled
+        self._login('mfauser', 'changeme')
+        # When requesting /mfa/ page
+        self.getPage("/mfa/")
+        self.assertStatus(200)
+        # Then a verification code is send to the user
+        self.assertInBody("new verification code sent to your email")
+
+    def test_verify_code_valid(self):
+        prev_session_id = self._session_id
+        # Given an authenticated user With MFA enabled
+        self._login('mfauser', 'changeme')
+        code = self._get_code()
+        # When sending a valid verification code
+        self.getPage("/mfa/", method='POST', body=urlencode({'code': code}))
+        # Then a new session_id is generated
+        self.assertNotEqual(prev_session_id, self._session_id)
+        # Then user is redirected to root page
+        self.assertStatus(303)
+        self.assertHeaderItemValue('Location', f'http://{self.HOST}:{self.PORT}/')
+        # Then user has access
+        self.getPage("/")
+        self.assertStatus(200)
+
+    def test_verify_code_invalid(self):
+        # Given an authenticated user With MFA enabled
+        # When sending an invalid verification code
+        self.getPage("/mfa/", method='POST', body=urlencode({'code': '1234567'}))
+        # Then user is redirected to login page
+        self.assertStatus(303)
+        self.assertHeaderItemValue('Location', f'http://{self.HOST}:{self.PORT}/login/')
+
+    def test_verify_code_expired(self):
+        # Given an authenticated user With MFA enabled
+        self._login('mfauser', 'changeme')
+        code = self._get_code()
+        # When sending a valid verification code that expired
+        session = RamSession.cache[self._session_id][0]
+
+        session[MFA_CODE_TIME] = datetime.datetime.now() - datetime.timedelta(minutes=MFA_DEFAULT_CODE_TIMEOUT + 1)
+
+        self.getPage("/mfa/", method='POST', body=urlencode({'code': code}))
+        # Then a new code get generated.
+        self.assertStatus(200)
+        self.assertInBody("invalid verification code")
+
+    def test_verify_code_invalid_after_3_tentative(self):
+        # Given an authenticated user With MFA
+        self._login('mfauser', 'changeme')
+        code = self._get_code()
+        # When user enter an invalid verification code 3 times
+        self.getPage("/mfa/", method='POST', body=urlencode({'code': '1234567'}))
+        self.assertStatus(200)
+        self.getPage("/mfa/", method='POST', body=urlencode({'code': '1234567'}))
+        self.assertStatus(200)
+        self.getPage("/mfa/", method='POST', body=urlencode({'code': '1234567'}))
+        # Then an error get displayed to the user
+        self.assertStatus(200)
+        self.assertInBody("invalid verification code")
+        # Then a new code get send to the user.
+        self.assertInBody("new verification code sent to your email")
+        session = RamSession.cache[self._session_id][0]
+        new_code = session['code']
+        self.assertNotEqual(code, new_code)
+
+    def test_resend_code(self):
+        # Given an authenticated user With MFA enabled with an existing code
+        self._login('mfauser', 'changeme')
+        code = self._get_code()
+        # When user request a new code
+        self.getPage("/mfa/", method='POST', body=urlencode({'resend_code': '1'}))
+        # Then A success message is displayedto the user.
+        self.assertInBody("new verification code sent to your email")
+        session = RamSession.cache[self._session_id][0]
+        new_code = session['code']
+        self.assertNotEqual(code, new_code)
+
+    def test_redirect_to_original_url(self):
+        # Given an authenticated user
+        self._login('mfauser', 'changeme')
+        # When querying a page that required mfa
+        self.getPage('/prefs/general')
+        # Then user is redirected to mfa page
+        self.assertStatus(303)
+        self.assertHeaderItemValue('Location', f'http://{self.HOST}:{self.PORT}/mfa/')
+        # When providing verification code
+        code = self._get_code()
+        self.getPage("/mfa/", method='POST', body=urlencode({'code': code}))
+        # Then user is redirected to original url
+        self.assertStatus(303)
+        self.assertHeaderItemValue('Location', f'http://{self.HOST}:{self.PORT}/prefs/general')
+
+    def test_login_persistent_when_login_timeout(self):
+        prev_session_id = self._session_id
+        # Given a user authenticated with MFA with "persistent"
+        self._login('mfauser', 'changeme')
+        code = self._get_code()
+        self.getPage("/mfa/", method='POST', body=urlencode({'code': code, 'persistent': '1'}))
+        self.assertStatus(303)
+        self.getPage("/")
+        self.assertStatus(200)
+        self.assertNotEqual(prev_session_id, self._session_id)
+        session = RamSession.cache[self._session_id][0]
+        self.assertTrue(session[SESSION_PERSISTENT])
+        # When the re-auth time expired (after 15 min)
+        session[AUTH_LAST_PASSWORD_AT] = datetime.datetime.now() - datetime.timedelta(minutes=60, seconds=1)
+
+        # Then next query redirect user to /login/ page (by mfa)
+        self.getPage("/")
+        self.assertStatus(303)
+        self.assertHeaderItemValue('Location', f'http://{self.HOST}:{self.PORT}/login/')
+        prev_session_id = self._session_id
+        # When user enter valid username password
+        self.getPage("/login/", method='POST', body=urlencode({'username': 'mfauser', 'password': 'changeme'}))
+        # Then user is redirected to original url without need to pass MFA again.
+        self.assertStatus(303)
+        self.assertHeaderItemValue('Location', f'http://{self.HOST}:{self.PORT}/')
+        self.assertNotEqual(prev_session_id, self._session_id)
+        self.getPage("/")
+        self.assertStatus(200)
+        self.assertInBody('OK')
+
+    def test_login_persistent_when_mfa_timeout(self):
+        prev_session_id = self._session_id
+        # Given a user authenticated with MFA with "persistent"
+        self._login('mfauser', 'changeme')
+        code = self._get_code()
+        self.getPage("/mfa/", method='POST', body=urlencode({'code': code, 'persistent': '1'}))
+        self.assertStatus(303)
+        self.getPage("/")
+        self.assertStatus(200)
+        self.assertNotEqual(prev_session_id, self._session_id)
+        session = RamSession.cache[self._session_id][0]
+
+        self.assertTrue(session[SESSION_PERSISTENT])
+        # When the mfa verification timeout (after 15 min)
+        session[MFA_VERIFICATION_TIME] = datetime.datetime.now() - datetime.timedelta(
+            minutes=MFA_DEFAULT_TRUST_DURATION, seconds=1
+        )
+
+        # Then next query redirect user to mfa page
+        self.getPage("/prefs/general")
+        self.assertStatus(303)
+        self.assertHeaderItemValue('Location', f'http://{self.HOST}:{self.PORT}/mfa/')
+        # When user enter valid code
+        code = self._get_code()
+        self.getPage("/mfa/", method='POST', body=urlencode({'code': code, 'persistent': '1'}))
+        # Then user is redirected to original page.
+        self.assertStatus(303)
+        self.assertHeaderItemValue('Location', f'http://{self.HOST}:{self.PORT}/prefs/general')
+        self.getPage("/")
+        self.assertStatus(200)
+        self.assertInBody('OK')