Odoo-Modules/fusion_claims/tests/test_application_received_wizard.py

# -*- coding: utf-8 -*-
import base64

from odoo.exceptions import UserError
from odoo.tests.common import TransactionCase, tagged


PDF_BYTES = b'%PDF-1.4\n%fake pdf for tests'
NOT_PDF_BYTES = b'this is not a pdf'


def _b64(data):
    return base64.b64encode(data)


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

    @classmethod
    def setUpClass(cls):
        super().setUpClass()
        cls.partner = cls.env['res.partner'].create({'name': 'ARW Test Client'})

    def _make_order(self):
        return self.env['sale.order'].create({
            'partner_id': self.partner.id,
            'x_fc_adp_application_status': 'waiting_for_application',
        })

    def _open_wizard(self, order, vals=None):
        wizard = self.env['fusion_claims.application.received.wizard'].with_context(
            active_id=order.id, active_model='sale.order',
        ).create({
            'sale_order_id': order.id,
            **(vals or {}),
        })
        return wizard

    # ---- bundled mode ----
    def test_bundled_mode_marks_received_with_only_original(self):
        order = self._make_order()
        wizard = self._open_wizard(order, {
            'intake_mode': 'bundled',
            'original_application': _b64(PDF_BYTES),
            'original_application_filename': 'app.pdf',
        })
        wizard.action_confirm()

        self.assertEqual(order.x_fc_adp_application_status, 'application_received')
        self.assertTrue(order.x_fc_pages_11_12_in_original)
        self.assertFalse(order.x_fc_signed_pages_11_12)
        self.assertTrue(order.x_fc_has_signed_pages_11_12)

    # ---- separate mode ----
    def test_separate_mode_requires_signed_pages(self):
        order = self._make_order()
        wizard = self._open_wizard(order, {
            'intake_mode': 'separate',
            'original_application': _b64(PDF_BYTES),
            'original_application_filename': 'app.pdf',
        })
        with self.assertRaises(UserError):
            wizard.action_confirm()

    def test_separate_mode_writes_both_files(self):
        order = self._make_order()
        wizard = self._open_wizard(order, {
            'intake_mode': 'separate',
            'original_application': _b64(PDF_BYTES),
            'original_application_filename': 'app.pdf',
            'signed_pages_11_12': _b64(PDF_BYTES),
            'signed_pages_filename': 'p11_12.pdf',
        })
        wizard.action_confirm()
        self.assertEqual(order.x_fc_adp_application_status, 'application_received')
        self.assertFalse(order.x_fc_pages_11_12_in_original)
        self.assertTrue(order.x_fc_signed_pages_11_12)

    # ---- remote mode ----
    def test_remote_mode_requires_sent_or_signed_request(self):
        order = self._make_order()
        wizard = self._open_wizard(order, {
            'intake_mode': 'remote',
            'original_application': _b64(PDF_BYTES),
            'original_application_filename': 'app.pdf',
        })
        with self.assertRaises(UserError):
            wizard.action_confirm()

    def test_remote_mode_passes_when_request_sent(self):
        order = self._make_order()
        self.env['fusion.page11.sign.request'].create({
            'sale_order_id': order.id,
            'signer_email': 'sign@example.com',
            'signer_type': 'client',
            'state': 'sent',
        })
        wizard = self._open_wizard(order, {
            'intake_mode': 'remote',
            'original_application': _b64(PDF_BYTES),
            'original_application_filename': 'app.pdf',
        })
        wizard.action_confirm()
        self.assertEqual(order.x_fc_adp_application_status, 'application_received')
        self.assertFalse(order.x_fc_pages_11_12_in_original)

    # ---- PDF magic-byte check ----
    def test_non_pdf_original_is_rejected(self):
        order = self._make_order()
        wizard = self._open_wizard(order, {
            'intake_mode': 'bundled',
            'original_application': _b64(NOT_PDF_BYTES),
            'original_application_filename': 'fake.pdf',
        })
        with self.assertRaises(UserError):
            wizard.action_confirm()

    def test_non_pdf_signed_pages_is_rejected(self):
        order = self._make_order()
        wizard = self._open_wizard(order, {
            'intake_mode': 'separate',
            'original_application': _b64(PDF_BYTES),
            'original_application_filename': 'app.pdf',
            'signed_pages_11_12': _b64(NOT_PDF_BYTES),
            'signed_pages_filename': 'p11_12.pdf',
        })
        with self.assertRaises(UserError):
            wizard.action_confirm()

    # ---- status gate ----
    def test_blocks_from_wrong_status(self):
        order = self._make_order()
        order.x_fc_adp_application_status = 'submitted'
        wizard = self._open_wizard(order, {
            'intake_mode': 'bundled',
            'original_application': _b64(PDF_BYTES),
            'original_application_filename': 'app.pdf',
        })
        with self.assertRaises(UserError):
            wizard.action_confirm()

    # ---- default_get picks initial mode ----
    def _get_defaults(self, order, fields_list=('intake_mode',)):
        return self.env['fusion_claims.application.received.wizard'].with_context(
            active_id=order.id, active_model='sale.order',
        ).default_get(list(fields_list))

    def test_default_intake_mode_bundled_on_fresh_order(self):
        order = self._make_order()
        defaults = self._get_defaults(order)
        self.assertEqual(defaults.get('intake_mode'), 'bundled')

    def test_default_intake_mode_bundled_when_flag_set(self):
        order = self._make_order()
        order.x_fc_pages_11_12_in_original = True
        defaults = self._get_defaults(order)
        self.assertEqual(defaults.get('intake_mode'), 'bundled')

    def test_default_intake_mode_separate_when_file_present(self):
        order = self._make_order()
        order.x_fc_signed_pages_11_12 = _b64(PDF_BYTES)
        order.x_fc_signed_pages_filename = 'p.pdf'
        defaults = self._get_defaults(order)
        self.assertEqual(defaults.get('intake_mode'), 'separate')

    def test_default_intake_mode_remote_when_request_pending(self):
        order = self._make_order()
        self.env['fusion.page11.sign.request'].create({
            'sale_order_id': order.id,
            'signer_email': 'a@b.com',
            'signer_type': 'client',
            'state': 'sent',
        })
        defaults = self._get_defaults(order)
        self.assertEqual(defaults.get('intake_mode'), 'remote')

    # ---- chatter ----
    def test_chatter_message_mentions_bundled(self):
        order = self._make_order()
        wizard = self._open_wizard(order, {
            'intake_mode': 'bundled',
            'original_application': _b64(PDF_BYTES),
            'original_application_filename': 'app.pdf',
        })
        wizard.action_confirm()
        messages = order.message_ids.mapped('body')
        self.assertTrue(
            any('bundled' in (m or '').lower() or 'included in original' in (m or '').lower()
                for m in messages),
            f"Expected bundled-mode chatter; got: {messages}",
        )