NoNameItem / django-magnificent-messages / 381

Build # 381

Build Type

cron

travis-ci

Committed by artem.vasin

Commit Message

chg: backend properties now cached properties

Run Details

139 of 212 branches covered (65.57%)

Branch coverage included in aggregate %.

15 of 15 new or added lines in 1 file covered. (100.0%)

7 existing lines in 1 file now uncovered.

946 of 1092 relevant lines covered (86.63%)

17.31 hits per line

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

90.28

/django_magnificent_messages/backend.py

from typing import Iterable

from django.utils.functional import cached_property
from django.utils.module_loading import import_string

from django_magnificent_messages.storage.message_storage.base import BaseMessageStorage
from django_magnificent_messages.storage.notification_storage.base import BaseNotificationStorage
from .conf import settings as config


class MessageBackend:
    def __init__(self, request):
        self._notification_storage = \
            import_string(config.DMM_NOTIFICATION_STORAGE)(request)  # type: BaseNotificationStorage
        self._message_storage = import_string(config.DMM_MESSAGE_STORAGE)(request)  # type: BaseMessageStorage

    @cached_property
    def notifications(self) -> Iterable:
        """Get notifications iterable"""
        return self._notification_storage

    @cached_property
    def notifications_count(self) -> int:
        """Get notifications count"""
        return len(self._notification_storage)

    @cached_property
    def all_messages(self) -> Iterable:
        """Get all messages"""
        return self._message_storage.all

    @cached_property
    def read_messages(self) -> Iterable:
        """Get read messages"""
        return self._message_storage.read

    @cached_property
    def unread_messages(self) -> Iterable:
        """Get unread messages"""
        return self._message_storage.unread

    @cached_property
    def archived_messages(self) -> Iterable:
        """Get archived messages"""
        return self._message_storage.archived

    @cached_property
    def new_messages(self) -> Iterable:
        """Get new messages"""
        return self._message_storage.new

    @cached_property
    def sent_messages(self) -> Iterable:
        """Get sent messages"""
        return self._message_storage.sent

    @cached_property
    def all_messages_count(self) -> int:
        """Get all messages count"""
        return self._message_storage.all_count

    @cached_property
    def read_messages_count(self) -> int:
        """Get read messages count"""
        return self._message_storage.read_count

    @cached_property
    def unread_messages_count(self) -> int:
        """Get unread messages count"""
        return self._message_storage.unread_count

    @cached_property
    def archived_messages_count(self) -> int:
        """Get archived messages count"""
        return self._message_storage.archived_count

    @cached_property
    def new_messages_count(self) -> int:
        """Get new messages count"""
        return self._message_storage.new_count

    @cached_property
    def sent_messages_count(self):
        return self._message_storage.sent_count

    def get_level(self) -> int:
        """Get minimal stored message/notification level"""
        return min(self._notification_storage.level, self._message_storage.level)

    def set_level(self, level: int) -> None:
        """Set minimal stored message/notification level"""
        self._notification_storage.level = level
        self._message_storage.level = level

    def add_notification(self, level: int, text: str, subject: str = None, extra=None) -> None:
        """Add new notification with specified level"""
        self._notification_storage.add(level, text, subject, extra)

    def send_message(self,
                     level: int,
                     text: str,
                     subject: str = None,
                     extra: object = None,
                     to_users_pk: Iterable = tuple(),
                     to_groups_pk: Iterable = tuple(),
                     user_generated: bool = True,
                     html_safe: bool = False,
                     reply_to_pk=None) -> None:
        """Add new message with specified level"""
        self._message_storage.send_message(level, text, subject, extra, to_users_pk, to_groups_pk, user_generated,
                                           html_safe, reply_to_pk)

    def update(self, response):
        return self._notification_storage.update(response)

    def mark_read(self, message_pk):
        self._message_storage.mark_read(message_pk)

    def mark_unread(self, message_pk):
        self._message_storage.mark_unread(message_pk)

    def archive(self, message_pk):
        self._message_storage.archive(message_pk)

    def unarchive(self, message_pk):
        self._message_storage.unarchive(message_pk)

    def update_last_checked(self):
        self._message_storage.update_last_checked()

1	from typing import Iterable	20✔
2
3	from django.utils.functional import cached_property	20✔
4	from django.utils.module_loading import import_string	20✔
5
6	from django_magnificent_messages.storage.message_storage.base import BaseMessageStorage	20✔
7	from django_magnificent_messages.storage.notification_storage.base import BaseNotificationStorage	20✔
8	from .conf import settings as config	20✔
9
10
11	class MessageBackend:	20✔
12	def __init__(self, request):	20✔
13	self._notification_storage = \	20✔
14	import_string(config.DMM_NOTIFICATION_STORAGE)(request) # type: BaseNotificationStorage
15	self._message_storage = import_string(config.DMM_MESSAGE_STORAGE)(request) # type: BaseMessageStorage	20✔
16
17	@cached_property	20✔
18	def notifications(self) -> Iterable:	20✔
19	"""Get notifications iterable"""
20	return self._notification_storage	20✔
21
22	@cached_property	20✔
23	def notifications_count(self) -> int:	20✔
24	"""Get notifications count"""
25	return len(self._notification_storage)	20✔
26
27	@cached_property	20✔
28	def all_messages(self) -> Iterable:	20✔
29	"""Get all messages"""
30	return self._message_storage.all	20✔
31
32	@cached_property	20✔
33	def read_messages(self) -> Iterable:	20✔
34	"""Get read messages"""
35	return self._message_storage.read	20✔
36
37	@cached_property	20✔
38	def unread_messages(self) -> Iterable:	20✔
39	"""Get unread messages"""
40	return self._message_storage.unread	20✔
41
42	@cached_property	20✔
43	def archived_messages(self) -> Iterable:	20✔
44	"""Get archived messages"""
45	return self._message_storage.archived	20✔
46
47	@cached_property	20✔
48	def new_messages(self) -> Iterable:	20✔
49	"""Get new messages"""
50	return self._message_storage.new	20✔
51
52	@cached_property	20✔
53	def sent_messages(self) -> Iterable:	20✔
54	"""Get sent messages"""
UNCOV 55	return self._message_storage.sent	×
56
57	@cached_property	20✔
58	def all_messages_count(self) -> int:	20✔
59	"""Get all messages count"""
60	return self._message_storage.all_count	20✔
61
62	@cached_property	20✔
63	def read_messages_count(self) -> int:	20✔
64	"""Get read messages count"""
65	return self._message_storage.read_count	20✔
66
67	@cached_property	20✔
68	def unread_messages_count(self) -> int:	20✔
69	"""Get unread messages count"""
70	return self._message_storage.unread_count	20✔
71
72	@cached_property	20✔
73	def archived_messages_count(self) -> int:	20✔
74	"""Get archived messages count"""
75	return self._message_storage.archived_count	20✔
76
77	@cached_property	20✔
78	def new_messages_count(self) -> int:	20✔
79	"""Get new messages count"""
80	return self._message_storage.new_count	20✔
81
82	@cached_property	20✔
83	def sent_messages_count(self):	10✔
UNCOV 84	return self._message_storage.sent_count	×
85
86	def get_level(self) -> int:	20✔
87	"""Get minimal stored message/notification level"""
88	return min(self._notification_storage.level, self._message_storage.level)	20✔
89
90	def set_level(self, level: int) -> None:	20✔
91	"""Set minimal stored message/notification level"""
92	self._notification_storage.level = level	20✔
93	self._message_storage.level = level	20✔
94
95	def add_notification(self, level: int, text: str, subject: str = None, extra=None) -> None:	20✔
96	"""Add new notification with specified level"""
97	self._notification_storage.add(level, text, subject, extra)	20✔
98
99	def send_message(self,	20✔
100	level: int,
101	text: str,
102	subject: str = None,
103	extra: object = None,
104	to_users_pk: Iterable = tuple(),
105	to_groups_pk: Iterable = tuple(),
106	user_generated: bool = True,
107	html_safe: bool = False,
108	reply_to_pk=None) -> None:
109	"""Add new message with specified level"""
110	self._message_storage.send_message(level, text, subject, extra, to_users_pk, to_groups_pk, user_generated,	20✔
111	html_safe, reply_to_pk)
112
113	def update(self, response):	20✔
114	return self._notification_storage.update(response)	20✔
115
116	def mark_read(self, message_pk):	20✔
UNCOV 117	self._message_storage.mark_read(message_pk)	×
118
119	def mark_unread(self, message_pk):	20✔
UNCOV 120	self._message_storage.mark_unread(message_pk)	×
121
122	def archive(self, message_pk):	20✔
UNCOV 123	self._message_storage.archive(message_pk)	×
124
125	def unarchive(self, message_pk):	20✔
UNCOV 126	self._message_storage.unarchive(message_pk)	×
127
128	def update_last_checked(self):	20✔
UNCOV 129	self._message_storage.update_last_checked()	×

NoNameItem / django-magnificent-messages / 381

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