agentsclimarketplace

Odoo e2e testing

Skill echozen88/odoo-claude-code/skills/odoo-e2e-testing

Production-ready agents, skills, hooks, commands, and rules tailored specifically for the Odoo ERP framework.From the repository description

Install
npx -y skills add echozen88/odoo-claude-code --skill odoo-e2e-testing

Assembled 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 TypeBase ClassPurposeTags
Unit TestTransactionCaseModel methods, constraints, business logicNone
Http TestHttpCaseHTTP requests, controllers, JSON APIsNone
UI TestHttpCase + browserUser interactions, form filling, click actionsNone
E2E TestHttpCase + browserComplete workflows, multi-page scenariospost_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

IssueCauseSolution
Record not foundTest isolation issueUse setUp for fresh data
Access deniedWrong user contextUse sudo() or with_user()
TimeoutAsync operation issueUse promises/correct async handling
Element not foundUI element missingCheck DOM structure, add waits
Assertion errorUnexpected stateDebug 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.

Keep looking

Skills are one crate of 610,677. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.