6433580518

Committed 06 Oct 2023 03:18PM UTC coverage: 87.833% (+0.3%) from 87.5%

Build # 6433580518

Build Type

push

github

Committed by

thomst

Commit Message

[tests] fixed tests

Run Details

231 of 263 relevant lines covered (87.83%)

7.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.04

/item_messages/storage/base.py

from collections import OrderedDict
from django.template.loader import render_to_string
from django.contrib.messages.storage.base import Message as BaseMessage
from ..utils import get_msg_path
from ..utils import get_model_key
from ..utils import get_msg_key


class Message(BaseMessage):
    #: Separator character to build the message id.
    id_separator = '_'

    def __init__(self, msg_key, model_key, obj_key, level, message, extra_tags="", extra_data=None):
        super().__init__(level, message, extra_tags)
        self.key = msg_key
        self.model_key = model_key
        self.obj_key = obj_key
        self.extra_data = extra_data

    @property
    def id(self):
        return f'{self.model_key}{self.id_separator}{self.obj_key}{self.id_separator}{self.key}'

    @property
    def html(self):
        return render_to_string('item_messages/item_message.html', {'msg': self})

    def __eq__(self, other):
        if not isinstance(other, Message):
            return NotImplemented
        return self.key == other.key


# FIXME: Make this class a dict type.
class StorageMixin:
    def _prepare_messages(self, messages):
        """
        _summary_
        """
        for model_msgs in messages.values():
            for obj_msgs in model_msgs.values():
                for msg in obj_msgs.values():
                    msg._prepare()

    @property
    def _loaded_messages(self):
        """
        _summary_
        """
        if not hasattr(self, "_loaded_data"):
            messages, _ = self._get()
            self._loaded_data = messages or dict()
        return self._loaded_data

    def update(self, response):
        """
        _summary_
        """
        self._prepare_messages(self._loaded_messages)
        return self._store(self._loaded_messages, response)

    def add(self, obj, level, message, extra_tags="", extra_data=None):
        """
        _summary_
        """
        if not message:
            return

        # Check that the message level is not less than the recording level.
        level = int(level)
        if level < self.level:
            return

        # Prepare the queued_messages dictonary.
        model_key, obj_key = get_msg_path(obj)
        if not model_key in self._loaded_messages:
            self._loaded_messages[model_key] = dict()
        if not obj_key in self._loaded_messages[model_key]:
            self._loaded_messages[model_key][obj_key] = OrderedDict()

        # Create and add message.
        msg_key = get_msg_key(self._loaded_messages[model_key][obj_key])
        msg = Message(msg_key, model_key, obj_key, level, message, extra_tags, extra_data)
        self._loaded_messages[msg.model_key][msg.obj_key][msg.key] = msg

        return msg.id

    def update_message(self, msg_id, level=None, message="", extra_tags="", extra_data=None):
        """
        _summary_

        :param str msg_key: _description_
        :param str message: _description_
        """
        msg = self.get(msg_id=msg_id)
        if msg:
            new_msg = Message(
                msg.key,
                msg.model_key,
                msg.obj_key,
                level or msg.level,
                message or msg.message,
                extra_tags or msg.extra_tags,
                extra_data or msg.extra_data,
                )
            self._loaded_messages[msg.model_key][msg.obj_key][msg.key] = new_msg

    def get(self, model=None, obj=None, msg_id=None):
        """
        Get either all or model specific or object specific messages.
        """
        if msg_id:
            model_key, obj_key, msg_key = msg_id.split(Message.id_separator)
            try:
                return self._loaded_messages.get(model_key, {}).get(obj_key, {})[msg_key]
            except KeyError:
                return None
        elif obj:
            model_key, obj_key = get_msg_path(obj)
            return self._loaded_messages.get(model_key, {}).get(obj_key, {})
        elif model:
            return self._loaded_messages.get(get_model_key(model), {})
        else:
            return self._loaded_messages

    def remove(self, model=None, obj=None, msg_id=None):
        """
        _summary_
        """
        if msg_id:
            model_key, obj_key, msg_key = msg_id.split(Message.id_separator)
            try:
                del self._loaded_messages.get(model_key, {}).get(obj_key, {})[msg_key]
            except KeyError:
                pass
        elif obj:
            model_key, obj_key = get_msg_path(obj)
            try:
                del self._loaded_messages.get(model_key, {})[obj_key]
            except KeyError:
                pass
        elif model:
            try:
                del self._loaded_messages[get_model_key(model)]
            except KeyError:
                pass
        else:
            self._loaded_messages
            del self._loaded_data

1	from collections import OrderedDict	9✔
2	from django.template.loader import render_to_string	9✔
3	from django.contrib.messages.storage.base import Message as BaseMessage	9✔
4	from ..utils import get_msg_path	9✔
5	from ..utils import get_model_key	9✔
6	from ..utils import get_msg_key	9✔
7
8
9	class Message(BaseMessage):	9✔
10	#: Separator character to build the message id.
11	id_separator = '_'	9✔
12
13	def __init__(self, msg_key, model_key, obj_key, level, message, extra_tags="", extra_data=None):	9✔
14	super().__init__(level, message, extra_tags)	9✔
15	self.key = msg_key	9✔
16	self.model_key = model_key	9✔
17	self.obj_key = obj_key	9✔
18	self.extra_data = extra_data	9✔
19
20	@property	9✔
21	def id(self):	7✔
22	return f'{self.model_key}{self.id_separator}{self.obj_key}{self.id_separator}{self.key}'	9✔
23
24	@property	9✔
25	def html(self):	7✔
26	return render_to_string('item_messages/item_message.html', {'msg': self})	9✔
27
28	def __eq__(self, other):	9✔
29	if not isinstance(other, Message):	×
30	return NotImplemented	×
31	return self.key == other.key	×
32
33
34	# FIXME: Make this class a dict type.
35	class StorageMixin:	9✔
36	def _prepare_messages(self, messages):	9✔
37	"""
38	_summary_
39	"""
40	for model_msgs in messages.values():	9✔
41	for obj_msgs in model_msgs.values():	9✔
42	for msg in obj_msgs.values():	9✔
43	msg._prepare()	9✔
44
45	@property	9✔
46	def _loaded_messages(self):	7✔
47	"""
48	_summary_
49	"""
50	if not hasattr(self, "_loaded_data"):	9✔
51	messages, _ = self._get()	9✔
52	self._loaded_data = messages or dict()	9✔
53	return self._loaded_data	9✔
54
55	def update(self, response):	9✔
56	"""
57	_summary_
58	"""
59	self._prepare_messages(self._loaded_messages)	9✔
60	return self._store(self._loaded_messages, response)	9✔
61
62	def add(self, obj, level, message, extra_tags="", extra_data=None):	9✔
63	"""
64	_summary_
65	"""
66	if not message:	9✔
67	return	×
68
69	# Check that the message level is not less than the recording level.
70	level = int(level)	9✔
71	if level < self.level:	9✔
72	return	×
73
74	# Prepare the queued_messages dictonary.
75	model_key, obj_key = get_msg_path(obj)	9✔
76	if not model_key in self._loaded_messages:	9✔
77	self._loaded_messages[model_key] = dict()	9✔
78	if not obj_key in self._loaded_messages[model_key]:	9✔
79	self._loaded_messages[model_key][obj_key] = OrderedDict()	9✔
80
81	# Create and add message.
82	msg_key = get_msg_key(self._loaded_messages[model_key][obj_key])	9✔
83	msg = Message(msg_key, model_key, obj_key, level, message, extra_tags, extra_data)	9✔
84	self._loaded_messages[msg.model_key][msg.obj_key][msg.key] = msg	9✔
85
86	return msg.id	9✔
87
88	def update_message(self, msg_id, level=None, message="", extra_tags="", extra_data=None):	9✔
89	"""
90	_summary_
91
92	:param str msg_key: _description_
93	:param str message: _description_
94	"""
95	msg = self.get(msg_id=msg_id)	9✔
96	if msg:	9✔
97	new_msg = Message(	9✔
98	msg.key,
99	msg.model_key,
100	msg.obj_key,
101	level or msg.level,
102	message or msg.message,
103	extra_tags or msg.extra_tags,
104	extra_data or msg.extra_data,
105	)
106	self._loaded_messages[msg.model_key][msg.obj_key][msg.key] = new_msg	9✔
107
108	def get(self, model=None, obj=None, msg_id=None):	9✔
109	"""
110	Get either all or model specific or object specific messages.
111	"""
112	if msg_id:	9✔
113	model_key, obj_key, msg_key = msg_id.split(Message.id_separator)	9✔
114	try:	9✔
115	return self._loaded_messages.get(model_key, {}).get(obj_key, {})[msg_key]	9✔
116	except KeyError:	×
117	return None	×
118	elif obj:	9✔
119	model_key, obj_key = get_msg_path(obj)	9✔
120	return self._loaded_messages.get(model_key, {}).get(obj_key, {})	9✔
121	elif model:	9✔
122	return self._loaded_messages.get(get_model_key(model), {})	9✔
123	else:
124	return self._loaded_messages	9✔
125
126	def remove(self, model=None, obj=None, msg_id=None):	9✔
127	"""
128	_summary_
129	"""
130	if msg_id:	9✔
131	model_key, obj_key, msg_key = msg_id.split(Message.id_separator)	9✔
132	try:	9✔
133	del self._loaded_messages.get(model_key, {}).get(obj_key, {})[msg_key]	9✔
134	except KeyError:	×
135	pass	×
136	elif obj:	9✔
137	model_key, obj_key = get_msg_path(obj)	9✔
138	try:	9✔
139	del self._loaded_messages.get(model_key, {})[obj_key]	9✔
140	except KeyError:	9✔
141	pass	9✔
142	elif model:	9✔
143	try:	9✔
144	del self._loaded_messages[get_model_key(model)]	9✔
145	except KeyError:	×
146	pass	×
147	else:
148	self._loaded_messages	9✔
149	del self._loaded_data	9✔

thomst / django-item-messages / 6433580518

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous