Julien Castiaux
f04b90b6e8
This commit is the 12th commit of a comprehensive refactor of our HTTP framework. See odoo/odoo#78857 for complete historic, discussions and rationnals. The web module is twofold, on one side there are many controllers: /, /web, /web/login, /web/database/selector, /web/dataset/call_kw, etc, on the other side there is `session_info`: the method responsible to create the web client's environ. This module is kinda an exception as it is (with base) a server wide module. In the case of the HTTP framework, it means that the controllers of web are always accessible, i.e. going to / or /web/login will never return a 404 Not Found even if the user is not connected to a database. This is both a blessing and a curse. It is a blessing because the controllers are always accessible it means that a new users can freely access those routes. It is a curse because *any* user can access them, even user who don't have a session yet thus who are not connected to a database yet. From a developer standpoint, we have to put extra care to correct serve users with and without a database. An example is the /web/login route, the login/password pair is stored in a database, without database it is impossible to validate a user login but users can still access this route without db. To solve this problem, there is the `ensure_db` function. This function attempts to find a database using various sources (?db= query-string, session db, mono db) and to save it on the user session. In case no db is found, the user is redirected to the database selector. In a way, this function grants a database to the user in a seamingly experience. In a way, this function brings a welcome differentiation between `auth='none'` with a database and `auth='none'` without a database. Such differentiation only matters for the server wide modules as "regular" module controllers are only accessible via the ir.http routing map, i.e. it is not possible to declare a nodb controller outside of server wide modules. An important changement is the `session.authenticate` method, before it was possible to call the method when the cursor was not yet initialized, authenticate would open a cursor against the given database, setup a registry and an environment and ultimately save everything on the current request. Because the cursor is now greedily created, it is no more possible to update the request environment when authenticating on another database. PR: odoo#78857 Task: 2571224
110 lines
5.2 KiB
Python
110 lines
5.2 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
import datetime
|
|
import json
|
|
|
|
from unittest.mock import patch
|
|
|
|
from odoo.tools import mute_logger
|
|
from odoo.tests.common import HttpCase, tagged
|
|
|
|
|
|
class ProfilingHttpCase(HttpCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
# Trick: we patch db_connect() to make it return the registry; when the
|
|
# profiler calls cursor() on it, it gets a test cursor (with cls.cr as
|
|
# its actual cursor), which prevents the profiling data from being
|
|
# committed for real.
|
|
cls.patcher = patch('odoo.sql_db.db_connect', return_value=cls.registry)
|
|
cls.patcher.start()
|
|
cls.addClassCleanup(cls.patcher.stop)
|
|
|
|
def profile_rpc(self, params=None):
|
|
params = params or {}
|
|
req = self.url_open(
|
|
'/web/dataset/call_kw/ir.profile/set_profiling', # use model and method in route has web client does
|
|
headers={'Content-Type': 'application/json'},
|
|
data=json.dumps({'params':{
|
|
'model': 'ir.profile',
|
|
'method': 'set_profiling',
|
|
'args': [],
|
|
'kwargs': params,
|
|
}})
|
|
)
|
|
req.raise_for_status()
|
|
return req.json()
|
|
|
|
|
|
@tagged('post_install', '-at_install', 'profiling')
|
|
class TestProfilingWeb(ProfilingHttpCase):
|
|
def test_profiling_enabled(self):
|
|
# since profiling will use a direct connection to the database patch 'db_connect' to ensure we are using the test cursor
|
|
self.authenticate('admin', 'admin')
|
|
last_profile = self.env['ir.profile'].search([], limit=1, order='id desc')
|
|
# Trying to start profiling when not enabled
|
|
self.env['ir.config_parameter'].set_param('base.profiling_enabled_until', '')
|
|
res = self.profile_rpc({'profile': 1})
|
|
self.assertEqual(res['result']['res_model'], 'base.enable.profiling.wizard')
|
|
self.assertEqual(last_profile, self.env['ir.profile'].search([], limit=1, order='id desc'))
|
|
|
|
# Enable profiling and start blank profiling
|
|
expiration = datetime.datetime.now() + datetime.timedelta(seconds=50)
|
|
self.env['ir.config_parameter'].set_param('base.profiling_enabled_until', expiration)
|
|
res = self.profile_rpc({'profile': 1})
|
|
self.assertTrue(res['result']['session'])
|
|
self.assertEqual(last_profile, self.env['ir.profile'].search([], limit=1, order='id desc'), "profiling route shouldn't have been profiled")
|
|
# Profile a page
|
|
res = self.url_open('/web/speedscope') # profile a light route
|
|
new_profile = self.env['ir.profile'].search([], limit=1, order='id desc')
|
|
self.assertNotEqual(last_profile, new_profile, "A new profile should have been created")
|
|
self.assertEqual(new_profile.name, '/web/speedscope?')
|
|
|
|
|
|
@tagged('post_install', '-at_install', 'profiling')
|
|
class TestProfilingModes(ProfilingHttpCase):
|
|
def test_profile_collectors(self):
|
|
expiration = datetime.datetime.now() + datetime.timedelta(seconds=50)
|
|
self.env['ir.config_parameter'].set_param('base.profiling_enabled_until', expiration)
|
|
|
|
self.authenticate('admin', 'admin')
|
|
res = self.profile_rpc({})
|
|
self.assertEqual(res['result']['collectors'], None)
|
|
res = self.profile_rpc({'profile': 1, 'collectors': ['sql', 'traces_async']})
|
|
self.assertEqual(sorted(res['result']['collectors']), ['sql', 'traces_async'])
|
|
res = self.profile_rpc({'collectors': ['sql']})
|
|
self.assertEqual(res['result']['collectors'], ['sql'],)
|
|
res = self.profile_rpc({'profile': 0})
|
|
res = self.profile_rpc({'profile': 1})
|
|
self.assertEqual(res['result']['collectors'], ['sql'],
|
|
"Enabling and disabling profiling shouldn't have change existing preferences")
|
|
|
|
|
|
@tagged('post_install', '-at_install', 'profiling')
|
|
class TestProfilingPublic(ProfilingHttpCase):
|
|
|
|
def test_public_user_profiling(self):
|
|
last_profile = self.env['ir.profile'].search([], limit=1, order='id desc')
|
|
self.env['ir.config_parameter'].set_param('base.profiling_enabled_until', '')
|
|
self.authenticate(None, None)
|
|
|
|
res = self.url_open('/web/set_profiling?profile=1')
|
|
self.assertEqual(res.status_code, 500)
|
|
self.assertEqual(res.text, 'error: Profiling is not enabled on this database. Please contact an administrator.')
|
|
|
|
expiration = datetime.datetime.now() + datetime.timedelta(seconds=50)
|
|
self.env['ir.config_parameter'].set_param('base.profiling_enabled_until', expiration)
|
|
res = self.url_open('/web/set_profiling?profile=1')
|
|
self.assertEqual(res.status_code, 200)
|
|
res = res.json()
|
|
self.assertTrue(res.pop('session'))
|
|
self.assertEqual(res, {"collectors": ["sql", "traces_async"], "params": {}})
|
|
self.assertEqual(last_profile, self.env['ir.profile'].search([], limit=1, order='id desc'), "profiling route shouldn't have been profiled")
|
|
|
|
res = self.url_open('/web/login') # profile /web/login to avoid redirections of /
|
|
new_profile = self.env['ir.profile'].search([], limit=1, order='id desc')
|
|
self.assertNotEqual(last_profile, new_profile, "A route should have been profiled")
|
|
self.assertEqual(new_profile.name, '/web/login?')
|