Odoo e2e testing
Production-ready agents, skills, hooks, commands, and rules tailored specifically for the Odoo ERP framework.From the repository description
npx -y skills add echozen88/odoo-claude-code --skill odoo-e2e-testingAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
2 things to look at
- no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
- 8 stars8 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
SKILL.md
23.2 KB, as published. Nobody here has run it
Odoo 19 E2E Testing Guide
This skill provides comprehensive guidance for end-to-end testing of Odoo 19 modules using HttpCase and UI testing frameworks.
Testing Framework Overview
Test Types
| Test Type | Base Class | Purpose | Tags |
|---|---|---|---|
| Unit Test | TransactionCase | Model methods, constraints, business logic | None |
| Http Test | HttpCase | HTTP requests, controllers, JSON APIs | None |
| UI Test | HttpCase + browser | User interactions, form filling, click actions | None |
| E2E Test | HttpCase + browser | Complete workflows, multi-page scenarios | post_install, -at_install |
Test Organization
tests/
├── __init__.py
├── test_model.py # Model/unit tests
├── test_security.py # Security/access tests
├── test_ui.py # UI interaction tests
├── test_workflows.py # E2E workflow tests
└── common.py # Shared test utilities
HttpCase Testing
Basic HttpCase
from odoo.tests import HttpCase, tagged
@tagged('post_install', '-at_install')
class TestHttpBasic(HttpCase):
"""Basic HTTP testing"""
def test_homepage_accessible(self):
"""Test that homepage is accessible"""
response = self.url_open('/web')
self.assertEqual(response.status_code, 200)
def test_login(self):
"""Test user login"""
response = self.url_open('/web/login', data={
'login': 'admin',
'password': 'admin',
})
self.assertEqual(response.status_code, 200)
def test_json_route(self):
"""Test JSON API endpoint"""
# Authenticate first
self.authenticate('admin', 'admin')
# Call JSON route
result = self.make_jsonrpc('/web/dataset/call_kw', {
'model': 'res.users',
'method': 'search_read',
'args': [[['id', '=', self.env.user.id]]],
'kwargs': {'fields': ['name', 'login']},
})
self.assertTrue(result)
self.assertEqual(len(result), 1)
self.assertEqual(result[0]['name'], 'Administrator')
Form Submission Tests
@tagged('post_install', '-at_install')
class TestFormSubmission(HttpCase):
"""Test form submissions"""
def setUp(self):
super(TestFormSubmission, self).setUp()
# Create test data
self.partner = self.env['res.partner'].create({
'name': 'Test Partner',
'email': '[email protected]',
})
def test_create_record_via_form(self):
"""Test creating record via web form"""
# Start tour or open form
self.start_tour('/web', 'my_module_create_record', login='admin')
def test_form_validation(self):
"""Test form client-side validation"""
self.authenticate('admin', 'admin')
response = self.url_open('/my_module/form')
self.assertIn('validation-error', response.text)
Controller Testing
@tagged('post_install', '-at_install')
class TestControllers(HttpCase):
"""Test HTTP controllers"""
def setUp(self):
super(TestControllers, self).setUp()
self.user = self.env['res.users'].create({
'name': 'Test User',
'login': 'testuser',
'password': 'testpass123',
'groups_id': [(6, 0, [self.env.ref('base.group_user').id])],
})
def test_public_route(self):
"""Test public route access"""
response = self.url_open('/my_module/public')
self.assertEqual(response.status_code, 200)
def test_protected_route_requires_auth(self):
"""Test protected route redirects to login"""
response = self.url_open('/my_module/protected')
# Should redirect to login
self.assertIn('/web/login', response.url)
def test_user_route_with_auth(self):
"""Test user route with authentication"""
self.authenticate(self.user.login, 'testpass123')
response = self.url_open('/my_module/protected')
self.assertEqual(response.status_code, 200)
def test_json_endpoint(self):
"""Test JSON API endpoint"""
self.authenticate('admin', 'admin')
response = self.make_jsonrpc('/my_module/api/create', {
'name': 'Test Record',
'value': 100,
})
self.assertTrue(response.get('success'))
self.assertIn('record_id', response)
UI Testing with Browser
Basic UI Test
from odoo.tests import HttpCase, tagged
from odoo.tests.common import HOST, PORT
@tagged('post_install', '-at_install', 'ui')
class TestUIBasic(HttpCase):
"""Basic UI testing"""
def test_load_module(self):
"""Test that module loads correctly"""
self.start_tour('/web', 'my_module_tour', login='admin')
def test_menu_accessible(self):
"""Test menu is accessible"""
self.authenticate('admin', 'admin')
# Click menu
self.browser_js('/web', """
return odoo.define('test', function (require) {
'use strict';
var core = require('web.core');
var menu_data = core.get_menu_data();
var module_menu = menu_data.children.filter(function (m) {
return m.id === 'my_module.menu_root';
});
return module_menu.length > 0;
});
""", "", 'MyModule')
def test_tree_view_renders(self):
"""Test tree view renders correctly"""
self.authenticate('admin', 'admin')
# Check tree view loads
self.browser_js('/web', """
return odoo.define('test', function (require) {
'use strict';
return new Promise(function (resolve) {
var action = {
type: 'ir.actions.act_window',
res_model: 'my.model',
view_mode: 'tree',
};
odoo.do_action(action).then(function () {
resolve(true);
});
});
});
""", "", 'MyModule')
Form Interaction Tests
@tagged('post_install', '-at_install', 'ui')
class TestFormInteraction(HttpCase):
"""Test form interactions"""
def setUp(self):
super(TestFormInteraction, self).setUp()
self.partner = self.env['res.partner'].create({
'name': 'Test Partner',
})
def test_create_record(self):
"""Test creating record from form"""
self.authenticate('admin', 'admin')
self.browser_js('/web', """
return odoo.define('test', function (require) {
'use strict';
return new Promise(function (resolve) {
var model = require('web.Model');
// Create record
model.call('create', [{
name: 'Test Record',
partner_id: %d,
}]).then(function (record_id) {
resolve(record_id > 0);
});
});
});
""" % self.partner.id, "", 'MyModule')
def test_edit_record(self):
"""Test editing record"""
record = self.env['my.model'].create({
'name': 'Test Record',
})
self.authenticate('admin', 'admin')
self.browser_js('/web', """
return odoo.define('test', function (require) {
'use strict';
return new Promise(function (resolve) {
var model = require('web.Model');
model.call('write', [[%d], {name: 'Updated Name'}])
.then(function () {
resolve(true);
});
});
});
""" % record.id, "", 'MyModule')
# Verify update
record.invalidate_cache()
self.assertEqual(record.name, 'Updated Name')
def test_form_validation(self):
"""Test form validation"""
self.authenticate('admin', 'admin')
# Test validation fails
with self.assertRaises(Exception):
self.env['my.model'].create({
'code': '', # Should fail constraint
})
E2E Workflow Testing
Complete User Journey
@tagged('post_install', '-at_install', 'ui')
class TestE2EWorkflows(HttpCase):
"""Test complete user workflows"""
def setUp(self):
super(TestE2EWorkflows, self).setUp()
# Create test data
self.customer = self.env['res.partner'].create({
'name': 'Test Customer',
'email': '[email protected]',
'customer_rank': 1,
})
self.product = self.env['product.product'].create({
'name': 'Test Product',
'list_price': 100.0,
'type': 'service',
})
self.user = self.env['res.users'].create({
'name': 'Sales User',
'login': 'salesuser',
'password': 'password123',
'groups_id': [(6, 0, [
self.env.ref('base.group_user').id,
self.env.ref('sales_team.group_sale_salesman').id,
])],
})
def test_create_and_confirm_order(self):
"""Test complete order creation and confirmation"""
self.authenticate('salesuser', 'password123')
# Step 1: Navigate to orders
self.browser_js('/web', """
return odoo.define('test', function (require) {
'use strict';
return new Promise(function (resolve) {
// Open order form
odoo.do_action({
type: 'ir.actions.act_window',
res_model: 'sale.order',
view_mode: 'form',
}).then(function () {
resolve(true);
});
});
});
""", "", 'Sales')
# Step 2: Create order programmatically
order = self.env['sale.order'].with_user(self.user).create({
'partner_id': self.customer.id,
'order_line': [
(0, 0, {
'product_id': self.product.id,
'product_uom_qty': 1.0,
'price_unit': 100.0,
}),
],
})
# Step 3: Confirm order
order.action_confirm()
self.assertEqual(order.state, 'sale')
def test_complete_customer_journey(self):
"""Test customer from lead to paid invoice"""
# Create lead
lead = self.env['crm.lead'].create({
'name': 'New Lead',
'contact_name': 'John Doe',
'email_from': '[email protected]',
})
# Convert to opportunity
lead.convert_opportunity({
'name': 'Test Opportunity',
'planned_revenue': 5000,
})
# Create quotation from opportunity
opportunity = self.env['crm.lead'].browse(lead.id)
quotation = self.env['sale.order'].create({
'partner_id': partner_id,
'opportunity_id': opportunity.id,
'order_line': [...],
})
# Confirm and create invoice
quotation.action_confirm()
invoice = quotation._create_invoices()
invoice.action_post()
# Verify payment
payment = self.env['account.payment'].create({
'payment_type': 'inbound',
'partner_type': 'customer',
'amount': invoice.amount_total,
'currency_id': invoice.currency_id.id,
'partner_id': invoice.partner_id.id,
'destination_account_id': self.env['account.account'].search([
('user_type_id', '=', self.env.ref('account.data_account_type_current_assets').id),
], limit=1).id,
})
payment.action_post()
payment.action_post()
self.assertEqual(invoice.payment_state, 'paid')
Multi-Step Workflow Test
@tagged('post_install', '-at_install')
class TestMultiStepWorkflow(HttpCase):
"""Test multi-step workflows"""
def test_approval_workflow(self):
"""Test document approval workflow"""
manager = self.env['res.users'].create({
'name': 'Manager',
'login': 'manager',
'groups_id': [(6, 0, [self.env.ref('my_module.group_manager').id])],
})
employee = self.env['res.users'].create({
'name': 'Employee',
'login': 'employee',
'groups_id': [(6, 0, [self.env.ref('my_module.group_user').id])],
})
# Step 1: Employee submits request
document = self.env['my.document'].with_user(employee).create({
'name': 'Test Document',
'description': 'Test content',
})
self.assertEqual(document.state, 'draft')
# Step 2: Employee submits for approval
document.action_submit()
self.assertEqual(document.state, 'pending')
# Step 3: Manager approves
document.with_user(manager).action_approve()
self.assertEqual(document.state, 'approved')
# Step 4: Employee can edit again if rejected
document.with_user(manager).action_reject()
self.assertEqual(document.state, 'rejected')
document.with_user(employee).write({'description': 'Updated'})
self.assertEqual(document.state, 'rejected')
def test_parallel_workflow(self):
"""Test parallel approval workflow"""
# Create multiple approvers
approver1 = self.env['res.users'].create({
'name': 'Approver 1',
'login': 'approver1',
})
approver2 = self.env['res.users'].create({
'name': 'Approver 2',
'login': 'approver2',
})
document = self.env['my.document'].create({
'name': 'Test Document',
})
document.action_submit()
# Both approvers need to approve
approval1 = self.env['document.approval'].create({
'document_id': document.id,
'user_id': approver1.id,
})
approval2 = self.env['document.approval'].create({
'document_id': document.id,
'user_id': approver2.id,
})
# First approval
approval1.action_approve()
self.assertEqual(document.state, 'pending')
# Second approval
approval2.action_approve()
self.assertEqual(document.state, 'approved')
Permission Boundary Testing
Access Rights Tests
@tagged('post_install', '-at_install')
class TestAccessRights(HttpCase):
"""Test access rights and permissions"""
def setUp(self):
super(TestAccessRights, self).setUp()
self.user = self.env['res.users'].create({
'name': 'Test User',
'login': 'testuser',
'password': 'password123',
})
self.manager = self.env['res.users'].create({
'name': 'Manager',
'login': 'manager',
'groups_id': [(6, 0, [self.env.ref('my_module.group_manager').id])],
})
# Create records
self.user_record = self.env['my.model'].create({
'name': 'User Record',
'user_id': self.user.id,
})
self.other_record = self.env['my.model'].create({
'name': 'Other Record',
'user_id': self.manager.id,
})
def test_user_can_read_own(self):
"""Test user can read own records"""
self.authenticate('testuser', 'password123')
records = self.env['my.model'].with_user(self.user).search([])
self.assertIn(self.user_record.id, records.ids)
self.assertNotIn(self.other_record.id, records.ids)
def test_user_cannot_delete_own(self):
"""Test user cannot delete own records (no unlink permission)"""
self.authenticate('testuser', 'password123')
with self.assertRaises(AccessError):
self.user_record.with_user(self.user).unlink()
def test_manager_can_delete(self):
"""Test manager can delete any record"""
self.authenticate('manager', 'password123')
record_id = self.user_record.id
self.user_record.with_user(self.manager).unlink()
self.assertFalse(self.env['my.model'].search([('id', '=', record_id)]))
def test_group_based_access(self):
"""Test group-based access control"""
# Remove user from module groups
self.user.write({'groups_id': [(5, self.env.ref('my_module.group_user').id)]})
self.authenticate('testuser', 'password123')
with self.assertRaises(AccessError):
self.env['my.model'].with_user(self.user).search([])
Record Rule Tests
@tagged('post_install', '-at_install')
class TestRecordRules(HttpCase):
"""Test record rules"""
def setUp(self):
super(TestRecordRules, self).setUp()
self.user1 = self.env['res.users'].create({
'name': 'User 1',
'login': 'user1',
'company_id': self.env.company.id,
})
self.user2 = self.env['res.users'].create({
'name': 'User 2',
'login': 'user2',
'company_id': self.env.company.id,
})
company2 = self.env['res.company'].create({
'name': 'Company 2',
})
self.user2.write({'company_id': company2.id})
# Create records
self.record1 = self.env['my.model'].create({
'name': 'Record 1',
'company_id': self.env.company.id,
})
self.record2 = self.env['my.model'].create({
'name': 'Record 2',
'company_id': company2.id,
})
def test_multi_company_isolation(self):
"""Test multi-company record isolation"""
self.authenticate('user2', 'password123')
# User2 should only see Company 2 records
records = self.env['my.model'].with_user(self.user2).search([])
self.assertIn(self.record2.id, records.ids)
self.assertNotIn(self.record1.id, records.ids)
Tour Testing
Define a Tour
<!-- static/tours/my_tour.js -->
odoo.define('my_module.my_tour', function (require) {
"use strict";
var tour = require('web_tour.tour');
var base = require('web_tour.tour_manager');
tour.register('my_module_create_record', {
url: '/web',
test: true,
rainbowMan: true,
}, [
{
content: "Click on My Module menu",
trigger: 'a:contains("My Module")',
},
{
content: "Click Create",
trigger: 'button.o_list_button_add',
},
{
content: "Enter name",
trigger: 'input[name="name"]',
run: "text Test Record",
},
{
content: "Select partner",
trigger: 'div.o_field_many2one input',
run: "text Test Partner",
},
{
content: "Wait for partner selection",
trigger: 'div.o_field_many2one_dropdown span:contains("Test Partner")',
run: "click",
},
{
content: "Click Save",
trigger: 'button.o_form_button_save',
},
{
content: "Record saved",
trigger: '.o_notification_manager:contains("Record saved")',
},
]);
return tour;
});
Run Tour in Test
@tagged('post_install', '-at_install', 'tour')
class TestTours(HttpCase):
"""Test UI tours"""
def test_my_module_tour(self):
"""Test complete UI tour"""
self.start_tour('/web', 'my_module_create_record', login='admin')
Common Test Patterns
Data Setup Pattern
class TestBase(TransactionCase):
"""Base test class with common setup"""
@classmethod
def setUpClass(cls):
super(TestBase, cls).setUpClass()
# Create common test data
cls.partner = cls.env['res.partner'].create({
'name': 'Test Partner',
'email': '[email protected]',
})
cls.product = cls.env['product.product'].create({
'name': 'Test Product',
'list_price': 100.0,
})
Assert Helper Pattern
def assert_record_state(self, record, expected_state, message=None):
"""Assert record state"""
self.assertEqual(
record.state,
expected_state,
message or f"Expected state {expected_state}, got {record.state}"
)
def assert_notification(self, notification_type, message=None):
"""Assert notification shown"""
notification = self.browser.find_element(
f'.o_notification_manager .o_notification_{notification_type}'
)
if message:
self.assertIn(message, notification.text)
Test Best Practices
1. Use Proper Tags
# Tests requiring demo data
@tagged('post_install', '-at_install')
# Tests that require UI
@tagged('post_install', '-at_install', 'ui')
# Tests that require database
@tagged('post_install')
# Tests that can run at install
@tagged('-post_install', 'at_install')
2. Isolate Tests
def test_method(self):
"""Each test should be independent"""
# Don't rely on previous test state
# Clean up after test
records = self.env['my.model'].search([])
records.unlink()
3. Use Meaningful Names
def test_user_can_create_draft_orders(self):
"""Test case name should describe what's being tested"""
pass
def test_manager_can_delete_cancelled_orders(self):
"""Include expected user and action"""
pass
def test_validation_fails_for_empty_email(self):
"""Include expected condition"""
pass
4. Assert Multiple Conditions
def test_order_creation(self):
"""Test order creation with multiple validations"""
order = self.env['sale.order'].create({...})
# Multiple assertions
self.assertTrue(order.id, 'Order should have ID')
self.assertEqual(order.state, 'draft', 'Order should be in draft state')
self.assertEqual(len(order.order_line), 1, 'Order should have one line')
self.assertAlmostEqual(order.amount_total, 100.0, places=2)
5. Use setUp Properly
def setUp(self):
"""Create fresh data for each test"""
super().setUp()
self.record = self.env['my.model'].create({'name': 'Test'})
@classmethod
def setUpClass(cls):
"""Create shared data once for all tests"""
super().setUpClass()
cls.shared_data = cls.env['my.model'].create({'name': 'Shared'})
Troubleshooting Tests
Common Test Failures
| Issue | Cause | Solution |
|---|---|---|
| Record not found | Test isolation issue | Use setUp for fresh data |
| Access denied | Wrong user context | Use sudo() or with_user() |
| Timeout | Async operation issue | Use promises/correct async handling |
| Element not found | UI element missing | Check DOM structure, add waits |
| Assertion error | Unexpected state | Debug with print/log statements |
Debug Tests
def test_with_debug(self):
"""Test with debugging enabled"""
import logging
_logger = logging.getLogger(__name__)
_logger.debug('Test starting')
record = self.env['my.model'].create({'name': 'Test'})
_logger.debug('Record created: %s', record.id)
_logger.debug('Record state: %s', record.state)
Remember: Good tests are isolated, repeatable, fast, and meaningful. They verify behavior, not implementation details.