from functools import partial from typing import Dict, Any, Sequence, Callable, Optional from django.db.models import Model from . import compare as base_compare from .comparison import _compare_mapping, register, CompareContext, unspecified, Registry def instance_fields(instance): opts = instance._meta for name in ( 'concrete_fields', 'virtual_fields', 'private_fields', ): fields = getattr(opts, name, None) if fields: for field in fields: yield field def model_to_dict( instance: Any, exclude: Sequence[str], include_not_editable: bool, ) -> Dict[str, Any]: data = {} for f in instance_fields(instance): if f.name in exclude: continue if not getattr(f, 'editable', False) and not include_not_editable: continue data[f.name] = f.value_from_object(instance) return data def compare_model(x, y, context: CompareContext): """ Returns an informative string describing the differences between the two supplied Django model instances. The way in which this comparison is performed can be controlled using the following parameters: :param ignore_fields: A sequence of fields to ignore during comparison, most commonly set to ``['id']``. By default, no fields are ignored. :param non_editable_fields: If `True`, then fields with ``editable=False`` will be included in the comparison. By default, these fields are ignored. """ ignore_fields = context.get_option('ignore_fields', set()) non_editable_fields= context.get_option('non_editable_fields', False) args = [] for obj in x, y: args.append(model_to_dict(obj, ignore_fields, non_editable_fields)) args.append(context) args.append(x) return _compare_mapping(*args) register(Model, compare_model) def compare( *args, x: Any = unspecified, y: Any = unspecified, expected: Any = unspecified, actual: Any = unspecified, prefix: str = None, suffix: str = None, x_label: str = None, y_label: str = None, raises: bool = True, recursive: bool = True, strict: bool = False, ignore_eq: bool = True, comparers: Registry = None, **options: Any ) -> Optional[str]: """ This is identical to :func:`~testfixtures.compare`, but with ``ignore=True`` automatically set to make comparing django :class:`~django.db.models.Model` instances easier. """ return base_compare( *args, x=x, y=y, expected=expected, actual=actual, prefix=prefix, suffix=suffix, x_label=x_label, y_label=y_label, raises=raises, recursive=recursive, strict=strict, ignore_eq=ignore_eq, comparers=comparers, **options )