odoo-stubs/odoo-stubs/tests/common.pyi

import collections
import logging
import unittest
from itertools import count
from re import Pattern
from types import TracebackType
from typing import (
    Any,
    Callable,
    Generator,
    Generic,
    Iterator,
    Literal,
    Mapping,
    Match,
    TypeVar,
)
from unittest import TestCase
from xmlrpc import client as xmlrpclib

import requests
from lxml.etree import _Element
from websocket import WebSocket

from ..api import Environment
from ..http import OpenERPSession
from ..models import BaseModel
from ..modules.registry import Registry
from ..sql_db import BaseCursor, Cursor
from ..tools import profiler
from ..tools.profiler import Profiler

_T = TypeVar("_T")
_CallableT = TypeVar("_CallableT", bound=Callable)
_ModelT = TypeVar("_ModelT", bound=BaseModel)
_FormT = TypeVar("_FormT", bound=Form)

ADDONS_PATH: str
HOST: str
ADMIN_USER_ID: int

def get_db_name() -> str: ...

standalone_tests: collections.defaultdict[str, list]

def standalone(*tags: str) -> Callable[[_CallableT], _CallableT]: ...

DB: str

def new_test_user(
    env: Environment,
    login: str = ...,
    groups: str = ...,
    context: dict | None = ...,
    **kwargs
) -> "odoo.model.res_users": ...

class RecordCapturer:
    _model: BaseModel
    _domain: list
    def __init__(self, model: BaseModel, domain: list) -> None: ...
    _before: BaseModel | None
    _after: BaseModel | None
    def __enter__(self: _T) -> _T: ...
    def __exit__(self, exc_type, exc_value, exc_traceback) -> None: ...
    @property
    def records(self) -> BaseModel: ...

class OdooSuite(unittest.suite.TestSuite):
    def __init__(self, *args, **kwargs) -> None: ...
    def _handleClassSetUp(self, test, result) -> None: ...
    def _createClassOrModuleLevelException(
        self, result, exc, method_name, parent, info: Any | None = ...
    ) -> None: ...
    def _addClassOrModuleLevelException(
        self, result, exception, errorName, info: Any | None = ...
    ) -> None: ...
    def _tearDownPreviousClass(self, test, result) -> None: ...

class MetaCase(type):
    def __init__(cls, name, bases, attrs) -> None: ...

def _normalize_arch_for_assert(arch_string: str, parser_method: str = ...) -> str: ...

class BaseCase(unittest.TestCase, metaclass=MetaCase):
    _python_version: tuple
    _class_cleanups: list
    tearDown_exceptions: list
    registry: Registry
    env: Environment
    cr: Cursor
    @classmethod
    def addClassCleanup(cls, function, *args, **kwargs) -> None: ...
    @classmethod
    def doClassCleanups(cls) -> None: ...
    longMessage: bool
    warm: bool
    def __init__(self, methodName: str = ...) -> None: ...
    def shortDescription(self) -> None: ...
    def cursor(self) -> Cursor: ...
    @property
    def uid(self) -> int: ...
    @uid.setter
    def uid(self, user) -> None: ...
    def ref(self, xid: str) -> int: ...
    def browse_ref(self, xid: str) -> BaseModel | None: ...
    def patch(self, obj, key, val) -> None: ...
    def with_user(self, login: str) -> None: ...
    def _assertRaises(
        self, exception, *, msg: Any | None = ...
    ) -> Generator[Any, None, None]: ...
    def assertRaises(
        self, exception, func: Any | None = ..., *args, **kwargs
    ) -> Generator[Any, None, None] | None: ...
    def assertQueries(
        self, expected, flush: bool = ...
    ) -> Generator[list, None, None]: ...
    def assertQueryCount(
        self, default: int = ..., flush: bool = ..., **counters
    ) -> Generator[None, None, None]: ...
    def assertRecordValues(
        self, records: BaseModel, expected_values: list[dict[str, Any]]
    ) -> None: ...
    def assertItemsEqual(self, a, b, msg: str | None = ...) -> None: ...
    def assertTreesEqual(self, n1, n2, msg: str | None = ...) -> None: ...
    def _assertXMLEqual(
        self, original: str, expected: str, parser: str = ...
    ) -> None: ...
    def assertXMLEqual(self, original: str, expected: str) -> None: ...
    def assertHTMLEqual(self, original: str, expected: str) -> None: ...
    profile_session: str
    def profile(self, description: str = ..., **kwargs) -> Profiler: ...
    def _callSetUp(self) -> None: ...

class _ErrorCatcher(list):
    __slots__ = ["test"]
    test: TestCase
    def __init__(self, test: TestCase) -> None: ...
    def append(self, error) -> None: ...
    def _complete_traceback(self, initial_tb: TracebackType) -> TracebackType: ...

savepoint_seq: count[int]

class TransactionCase(BaseCase):
    registry: Registry
    env: Environment
    cr: Cursor
    @classmethod
    def setUpClass(cls) -> None: ...
    _savepoint_id: int
    def setUp(self): ...

class SavepointCase(TransactionCase):
    @classmethod
    def __init_subclass__(cls) -> None: ...

class SingleTransactionCase(BaseCase):
    @classmethod
    def __init_subclass__(cls) -> None: ...
    @classmethod
    def setUpClass(cls) -> None: ...
    def setUp(self) -> None: ...

class ChromeBrowserException(Exception): ...

class ChromeBrowser:
    test_class: str
    devtools_port: int | None
    ws_url: str
    ws: WebSocket | None
    request_id: int
    user_data_dir: str
    chrome_pid: int | None
    screenshots_dir: str
    screencasts_dir: str | None
    screencast_frames: list
    window_size: str
    sigxcpu_handler: Any
    def __init__(
        self, logger: logging.Logger, window_size: str, test_class: str
    ) -> None: ...
    def signal_handler(self, sig, frame) -> None: ...
    def stop(self) -> None: ...
    @property
    def executable(self) -> str | None: ...
    def _spawn_chrome(self, cmd: list[str]) -> int | None: ...
    def _chrome_start(self) -> None: ...
    def _find_websocket(self) -> None: ...
    def _json_command(
        self, command: str, timeout: int = ..., get_key: Any | None = ...
    ): ...
    def _open_websocket(self) -> None: ...
    def _websocket_send(self, method: str, params: Any | None = ...) -> int | None: ...
    def _get_message(self, raise_log_error: bool = ...) -> dict: ...
    _TO_LEVEL: dict[str, int]
    def _websocket_wait_id(self, awaited_id: int, timeout: int = ...) -> dict: ...
    def _websocket_wait_event(
        self, method: str, params: dict | None = ..., timeout: int = ...
    ) -> dict | None: ...
    def take_screenshot(self, prefix: str = ..., suffix: str | None = ...) -> None: ...
    def _save_screencast(self, prefix: str = ...) -> None: ...
    screencasts_frames_dir: str
    def start_screencast(self) -> None: ...
    def set_cookie(self, name: str, value, path, domain) -> dict: ...
    def delete_cookie(self, name: str, **kwargs) -> dict: ...
    def _wait_ready(self, ready_code, timeout: int = ...) -> bool: ...
    def _wait_code_ok(self, code, timeout: float) -> Literal[True] | None: ...
    def navigate_to(self, url: str, wait_stop: bool = ...) -> None: ...
    def clear(self) -> None: ...
    def _from_remoteobject(self, arg: Mapping): ...
    LINE_PATTERN: str
    def _format_stack(self, logrecord: Mapping) -> None: ...
    def console_formatter(self, args: list) -> Callable[[Match[str]], str]: ...

class Opener(requests.Session):
    cr: BaseCursor
    def __init__(self, cr: BaseCursor) -> None: ...
    def request(self, *args, **kwargs): ...

class Transport(xmlrpclib.Transport):
    cr: BaseCursor
    def __init__(self, cr: BaseCursor) -> None: ...
    def request(self, *args, **kwargs): ...

class HttpCase(TransactionCase):
    registry_test_mode: bool
    browser: ChromeBrowser
    browser_size: str
    _logger: logging.Logger
    @classmethod
    def setUpClass(cls) -> None: ...
    xmlrpc_common: xmlrpclib.ServerProxy
    xmlrpc_db: xmlrpclib.ServerProxy
    xmlrpc_object: xmlrpclib.ServerProxy
    opener: Opener
    def setUp(self) -> None: ...
    @classmethod
    def start_browser(cls) -> None: ...
    @classmethod
    def terminate_browser(cls) -> None: ...
    def url_open(
        self,
        url: str,
        data: Any | None = ...,
        files: Mapping | None = ...,
        timeout: int = ...,
        headers: Mapping | None = ...,
        allow_redirects: bool = ...,
        head: bool = ...,
    ) -> requests.Response: ...
    def _wait_remaining_requests(self, timeout: int = ...) -> None: ...
    def logout(self, keep_db: bool = ...) -> None: ...
    session: OpenERPSession
    def authenticate(self, user, password) -> OpenERPSession: ...
    def browser_js(
        self,
        url_path: str,
        code: str,
        ready: str = ...,
        login: str | None = ...,
        timeout: int = ...,
        cookies: Any | None = ...,
        **kw
    ) -> None: ...
    @classmethod
    def base_url(cls) -> str: ...
    def start_tour(
        self, url_path: str, tour_name: str, step_delay: float | None = ..., **kwargs
    ) -> None: ...
    def profile(self, **kwargs) -> profiler.Nested: ...

class HttpSavepointCase(HttpCase):
    @classmethod
    def __init_subclass__(cls) -> None: ...

def users(*logins: str) -> Callable[[_CallableT], _CallableT]: ...
def warmup(func: _CallableT, *args, **kwargs) -> _CallableT: ...
def can_import(module: str) -> bool: ...

ref_re: Pattern

class Form(Generic[_ModelT]):
    _env: Environment
    _model: _ModelT
    _view: dict
    _values: dict
    _changed: set
    def __init__(self, recordp: _ModelT, view: _ModelT | str | None = ...) -> None: ...
    def _o2m_set_edition_view(
        self, descr: dict, node: _Element, level: int
    ) -> None: ...
    def __str__(self) -> str: ...
    def _process_fvg(self, model: BaseModel, fvg: dict, level: int = ...) -> None: ...
    def _init_from_defaults(self, model: BaseModel) -> None: ...
    def _init_from_values(self, values: BaseModel) -> None: ...
    def __getattr__(self, field: str): ...
    def _get_modifier(
        self,
        field: str,
        modifier: str,
        *,
        default: Any = ...,
        view: Any = ...,
        modmap: Any | None = ...,
        vals: Any | None = ...
    ): ...
    _OPS: dict[str, Callable[..., bool]]
    def _get_context(self, field: str): ...
    def __setattr__(self, field: str, value) -> None: ...
    def __enter__(self: _FormT) -> _FormT: ...
    def __exit__(self, etype, _evalue, _etb) -> None: ...
    def save(self) -> _ModelT: ...
    def _values_to_save(self, all_fields: bool = ...) -> dict: ...
    def _values_to_save_(
        self,
        record_values: dict,
        fields: dict,
        view: Any,
        changed: set,
        all_fields: bool = ...,
        modifiers_values: dict | None = ...,
        parent_link: Any | None = ...,
    ) -> dict: ...
    def _perform_onchange(self, fields: list[str]) -> dict: ...
    def _onchange_values(self) -> dict: ...
    def _onchange_values_(self, fields, record: dict) -> dict: ...
    def _cleanup_onchange(self, descr: dict, value, current): ...

class O2MForm(Form):
    _proxy: O2MProxy
    _index: int | None
    def __init__(self, proxy: O2MProxy, index: int | None = ...) -> None: ...
    def _get_modifier(
        self,
        field: str,
        modifier: str,
        *,
        default: Any = ...,
        view: Any = ...,
        modmap: Any | None = ...,
        vals: Any | None = ...
    ): ...
    def _onchange_values(self) -> dict: ...
    def save(self) -> None: ...
    def _values_to_save(self, all_fields: bool = ...) -> UpdateDict: ...

class UpdateDict(dict):
    _changed: set
    def __init__(self, *args, **kwargs) -> None: ...
    def changed_items(self) -> Iterator[tuple[Any, Any]]: ...
    def update(self, *args, **kw) -> None: ...

class X2MProxy:
    _parent: Form
    _field: str
    def _assert_editable(self) -> None: ...

class O2MProxy(X2MProxy):
    _records: list[dict]
    def __init__(self, parent: Form, field: str) -> None: ...
    def __len__(self) -> int: ...
    @property
    def _model(self) -> BaseModel: ...
    @property
    def _descr(self) -> dict: ...
    def _command_index(self, for_record: int) -> int: ...
    def new(self) -> O2MForm: ...
    def edit(self, index: int): ...
    def remove(self, index: int) -> None: ...

class M2MProxy(X2MProxy, collections.Sequence):
    def __init__(self, parent: Form, field: str) -> None: ...
    def __getitem__(self, it) -> BaseModel: ...
    def __len__(self) -> int: ...
    def __iter__(self) -> Iterator[BaseModel]: ...
    def __contains__(self, record: BaseModel) -> bool: ...
    def add(self, record: BaseModel) -> None: ...
    def _get_ids(self) -> list[int]: ...
    def remove(self, id: int | None = ..., index: int | None = ...) -> None: ...
    def clear(self) -> None: ...

def record_to_values(fields: dict, record: BaseModel) -> dict: ...
def _cleanup_from_default(type_: str, value): ...
def _get_node(view, f, *arg): ...
def tagged(*tags: str) -> Callable[[_CallableT], _CallableT]: ...

class TagsSelector:
    filter_spec_re: Pattern
    exclude: set
    include: set
    def __init__(self, spec: str) -> None: ...
    def check(self, test) -> bool: ...