Testing Framework in Odoo 19:
Unit, Integration & Tour Tests

from odoo.tests.common import SavepointCase, tagged


@tagged('post_install', '-at_install')
class TestInvoiceWorkflow(SavepointCase):
    """Integration tests for the full order-to-invoice flow.

    SavepointCase is ideal here because each test method builds
    on shared setup data, and the savepoint rollback between
    methods is 10-50x faster than full transaction rollback.
    """

    @classmethod
    def setUpClass(cls):
        super().setUpClass()

        cls.partner = cls.env['res.partner'].create({
            'name': 'Integration Customer',
            'email': 'integration@example.com',
        })
        cls.product = cls.env['product.product'].create({
            'name': 'Service Package',
            'list_price': 500.0,
            'type': 'service',
            'invoice_policy': 'order',
        })
        cls.pricelist = cls.env['product.pricelist'].create({
            'name': 'Test Pricelist',
            'currency_id': cls.env.ref('base.USD').id,
        })

    def test_01_create_and_confirm_order(self):
        """Create SO, approve discount, confirm."""
        self.order = self.env['sale.order'].create({
            'partner_id': self.partner.id,
            'pricelist_id': self.pricelist.id,
            'order_line': [(0, 0, {
                'product_id': self.product.id,
                'product_uom_qty': 2,
                'price_unit': 500.0,
                'discount': 20.0,
            })],
        })
        self.order.discount_approved = True
        self.order.action_confirm()
        self.assertEqual(self.order.state, 'sale')

    def test_02_generate_invoice(self):
        """Generate invoice from confirmed SO."""
        # Re-fetch order (savepoint may have rolled back)
        orders = self.env['sale.order'].search([
            ('partner_id', '=', self.partner.id),
            ('state', '=', 'sale'),
        ])
        if not orders:
            # Re-create if savepoint rolled back
            self.test_01_create_and_confirm_order()
            orders = self.env['sale.order'].search([
                ('partner_id', '=', self.partner.id),
                ('state', '=', 'sale'),
            ])
        order = orders[0]
        invoice_wizard = self.env['sale.advance.payment.inv'].with_context(
            active_ids=order.ids,
            active_model='sale.order',
        ).create({
            'advance_payment_method': 'delivered',
        })
        invoice_wizard.create_invoices()
        self.assertTrue(
            order.invoice_ids,
            "Invoice should be created from the sale order"
        )

    def test_03_invoice_discount_matches_order(self):
        """Invoice lines should carry the same discount as SO lines."""
        invoices = self.env['account.move'].search([
            ('partner_id', '=', self.partner.id),
            ('move_type', '=', 'out_invoice'),
        ])
        for invoice in invoices:
            for line in invoice.invoice_line_ids:
                self.assertEqual(
                    line.discount, 20.0,
                    "Invoice line discount should match SO line"
                )

#!/bin/bash
# scripts/run_tests.sh — CI-safe Odoo test runner
set -euo pipefail

DB_NAME="${1:-odoo_test}"
MODULES="${2:-my_module}"
LOG_FILE="/tmp/odoo_test_output.log"

echo "=== Running tests for: $MODULES ==="

python odoo-bin \
    -d "$DB_NAME" \
    --addons-path=odoo/addons,custom_addons \
    -u "$MODULES" \
    --test-enable \
    --test-tags=post_install \
    --stop-after-init \
    --log-level=test \
    2>&1 | tee "$LOG_FILE"

# Count failures and errors
ERRORS=$(grep -c "ERROR.*odoo\.\(tests\|modules\)" "$LOG_FILE" || true)
FAILS=$(grep -c "FAIL:" "$LOG_FILE" || true)

echo "=== Results: $ERRORS errors, $FAILS failures ==="

if [ "$ERRORS" -gt 0 ] || [ "$FAILS" -gt 0 ]; then
    echo "::error::Tests failed: $ERRORS errors, $FAILS failures"
    grep -E "(ERROR|FAIL:)" "$LOG_FILE"
    exit 1
fi

echo "All tests passed."
exit 0

from unittest.mock import patch, MagicMock
from odoo.tests.common import TransactionCase, tagged


@tagged('post_install', '-at_install')
class TestShippingRateCalculation(TransactionCase):

    @classmethod
    def setUpClass(cls):
        super().setUpClass()
        cls.partner = cls.env['res.partner'].create({
            'name': 'Shipping Customer',
            'street': '123 Test St',
            'city': 'New York',
            'zip': '10001',
            'country_id': cls.env.ref('base.us').id,
        })

    @patch('odoo.addons.my_module.models.sale_order.requests.post')
    def test_shipping_rate_api_called(self, mock_post):
        """Verify the shipping API is called with correct payload."""
        # Configure the mock to return a fake API response
        mock_response = MagicMock()
        mock_response.status_code = 200
        mock_response.json.return_value = {
            'rate': 12.50,
            'currency': 'USD',
            'carrier': 'UPS Ground',
            'estimated_days': 5,
        }
        mock_post.return_value = mock_response

        # Trigger the shipping rate calculation
        order = self.env['sale.order'].create({
            'partner_id': self.partner.id,
            'partner_shipping_id': self.partner.id,
        })
        order._compute_shipping_rate()

        # Verify the API was called
        mock_post.assert_called_once()
        call_args = mock_post.call_args
        payload = call_args[1]['json']
        self.assertEqual(payload['destination_zip'], '10001')

        # Verify the rate was stored
        self.assertAlmostEqual(
            order.shipping_rate, 12.50, places=2
        )

    @patch('odoo.addons.my_module.models.sale_order.requests.post')
    def test_shipping_api_failure_handled(self, mock_post):
        """API failure should not crash — should log and set rate to 0."""
        mock_post.side_effect = ConnectionError("API timeout")

        order = self.env['sale.order'].create({
            'partner_id': self.partner.id,
            'partner_shipping_id': self.partner.id,
        })
        # Should not raise
        order._compute_shipping_rate()
        self.assertEqual(
            order.shipping_rate, 0.0,
            "Shipping rate should default to 0 on API failure"
        )

    def test_override_env_context(self):
        """Test with a modified environment context.

        Odoo's with_context() and with_user() methods let you
        test behavior under different contexts without mocking.
        """
        # Test as a non-admin user
        sales_user = self.env['res.users'].create({
            'name': 'Sales Rep',
            'login': 'salesrep@test.com',
            'groups_id': [(6, 0, [
                self.env.ref('sales_team.group_sale_salesman').id,
            ])],
        })
        order_as_user = self.env['sale.order'].with_user(
            sales_user
        ).create({
            'partner_id': self.partner.id,
        })
        # Sales rep should not be able to approve discounts
        with self.assertRaises(Exception):
            order_as_user.action_approve_discount()