Testing Your Odoo Modules: Unit Tests and Integration Tests Tutorial

custom_module/
├── tests/
│   ├── __init__.py
│   └── test_sale_order.py
└── __manifest__.py

from odoo.tests.common import TransactionCase
from odoo.exceptions import ValidationError

class TestSaleOrder(TransactionCase):
    """Test cases for sale.order model."""
    
    @classmethod
    def setUpClass(cls):
        """Set up test data once for all tests."""
        super().setUpClass()
        
        # Create test customer
        cls.customer = cls.env['res.partner'].create({
            'name': 'Test Customer',
            'email': 'test@example.com',
            'country_id': cls.env.ref('base.us').id,
        })
        
        # Create test product
        cls.product = cls.env['product.product'].create({
            'name': 'Test Product',
            'list_price': 100,
            'cost': 50,
        })
    
    def setUp(self):
        """Run before each test method."""
        super().setUp()
        
        # Create a fresh order for each test
        self.order = self.env['sale.order'].create({
            'partner_id': self.customer.id,
            'order_line': [
                (0, 0, {
                    'product_id': self.product.id,
                    'product_qty': 2,
                    'price_unit': 100,
                })
            ],
        })
    
    # TEST METHODS
    def test_order_creation(self):
        """Test that order is created with correct values."""
        self.assertEqual(self.order.partner_id, self.customer)
        self.assertEqual(len(self.order.order_line), 1)
        self.assertEqual(self.order.state, 'draft')
    
    def test_order_total_calculation(self):
        """Test that order total is calculated correctly."""
        # 2 items × $100 = $200
        self.assertEqual(self.order.amount_subtotal, 200)
        
        # Tax: $200 × 8% = $16
        self.assertEqual(self.order.amount_tax, 16)
        
        # Total: $200 + $16 = $216
        self.assertEqual(self.order.amount_total, 216)
    
    def test_discount_application(self):
        """Test that discount reduces total correctly."""
        # Apply 10% discount
        self.order.discount_percent = 10
        
        # Subtotal unchanged
        self.assertEqual(self.order.amount_subtotal, 200)
        
        # Tax on discounted amount
        expected_tax = (200 - 20) * 0.08  # $14.40
        self.assertAlmostEqual(self.order.amount_tax, expected_tax, places=2)
        
        # Total: $180 + $14.40 = $194.40
        self.assertAlmostEqual(self.order.amount_total, 194.40, places=2)
    
    def test_validation_error_on_negative_quantity(self):
        """Test that negative quantity raises ValidationError."""
        with self.assertRaises(ValidationError):
            self.order.order_line[0].product_qty = -1

# Run all tests in module
python -m odoo -c /path/to/odoo.conf -d test_database -m custom_module --test-enable

# Run specific test file
python -m odoo -c /path/to/odoo.conf -d test_database -m custom_module --test-enable --test-file=tests/test_sale_order.py

# Run specific test class
python -m odoo -c /path/to/odoo.conf -d test_database -m custom_module --test-enable -u custom_module --test-tags="test_sale_order"

from odoo.tests.common import TransactionCase

class TestSaleOrderIntegration(TransactionCase):
    """Integration tests for order → inventory → accounting."""
    
    @classmethod
    def setUpClass(cls):
        super().setUpClass()
        cls.customer = cls.env['res.partner'].create({'name': 'Customer'})
        cls.product = cls.env['product.product'].create({
            'name': 'Product',
            'list_price': 100,
            'cost': 50,
        })
    
    def test_order_confirmation_updates_inventory(self):
        """When order confirms, inventory should be reserved."""
        # Create order
        order = self.env['sale.order'].create({
            'partner_id': self.customer.id,
            'order_line': [(0, 0, {
                'product_id': self.product.id,
                'product_qty': 10,
            })],
        })
        
        # Confirm order
        order.action_confirm()
        
        # Check inventory was reserved
        stock_moves = self.env['stock.move'].search([
            ('sale_line_id.order_id', '=', order.id),
            ('state', '=', 'confirmed'),
        ])
        self.assertEqual(len(stock_moves), 1)
        self.assertEqual(stock_moves.product_qty, 10)
    
    def test_order_creates_accounting_entries(self):
        """When order confirms, accounting entries should be created."""
        order = self.env['sale.order'].create({
            'partner_id': self.customer.id,
            'order_line': [(0, 0, {
                'product_id': self.product.id,
                'product_qty': 5,
                'price_unit': 100,
            })],
        })
        order.action_confirm()
        
        # Create invoice from order
        invoice = order._create_invoices()
        
        # Check invoice exists and has correct total
        self.assertTrue(invoice)
        self.assertEqual(invoice.amount_total, 500)  # 5 × $100
    
    def test_order_sends_confirmation_email(self):
        """When order confirms, email should be sent."""
        order = self.env['sale.order'].create({
            'partner_id': self.customer.id,
            'order_line': [(0, 0, {
                'product_id': self.product.id,
                'product_qty': 1,
            })],
        })
        
        # Mock email sending
        with self.assertLogs(level='INFO'):
            order.action_confirm()
        
        # Check email was queued
        mail = self.env['mail.mail'].search([
            ('email_to', '=', self.customer.email),
        ])
        self.assertTrue(mail)

import pytest
from odoo import fields

@pytest.fixture
def test_customer(env):
    """Create a test customer."""
    return env['res.partner'].create({
        'name': 'Test Customer',
        'email': 'test@example.com',
        'country_id': env.ref('base.us').id,
    })

@pytest.fixture
def test_product(env):
    """Create a test product."""
    return env['product.product'].create({
        'name': 'Test Product',
        'list_price': 100,
        'cost': 50,
    })

@pytest.fixture
def test_order(env, test_customer, test_product):
    """Create a test order."""
    return env['sale.order'].create({
        'partner_id': test_customer.id,
        'order_line': [(0, 0, {
            'product_id': test_product.id,
            'product_qty': 2,
            'price_unit': 100,
        })],
    })

# Usage in tests:
def test_order_total(test_order):
    """Test order total using fixture."""
    assert test_order.amount_total == 216  # 2×100 + tax

from unittest.mock import patch, MagicMock

def test_order_sends_email(self):
    """Test email sending without actually sending."""
    order = self.env['sale.order'].create({
        'partner_id': self.customer.id,
        'order_line': [(0, 0, {'product_id': self.product.id})],
    })
    
    # Mock the email sending method
    with patch.object(order, 'send_confirmation_email') as mock_send:
        order.action_confirm()
        
        # Verify email method was called
        mock_send.assert_called_once()

def test_external_api_call(self):
    """Test code that calls external API without hitting real API."""
    with patch('custom_module.models.requests.post') as mock_post:
        # Mock the API response
        mock_post.return_value = MagicMock(
            status_code=200,
            json=lambda: {'success': True, 'order_id': 12345}
        )
        
        # Call code that uses API
        result = self.env['sale.order'].call_external_api()
        
        # Verify API was called with correct parameters
        mock_post.assert_called_once()
        self.assertTrue(result['success'])

# Equality
self.assertEqual(order.state, 'sale')
self.assertNotEqual(order.state, 'draft')

# Truthiness
self.assertTrue(order.confirmed)
self.assertFalse(order.cancelled)

# Numbers
self.assertAlmostEqual(order.total, 100.00, places=2)
self.assertGreater(order.total, 50)
self.assertLess(order.total, 200)

# Collections
self.assertIn('tax', order._fields)  # Field exists
self.assertNotIn('deleted_field', order._fields)

# Exceptions
with self.assertRaises(ValidationError):
    order.invalid_operation()

# Records
self.assertEqual(len(order.order_line), 3)
self.assertTrue(order.exists())
self.assertRecordValues(order, [{'state': 'sale'}])