Produits Entr'ouvert » Combo

class NotificationSerializer(serializers.Serializer):

    summary = serializers.CharField(required=True, allow_blank=False, max_length=140)

    id = serializers.SlugField(required=False, allow_null=True)

    start_timestamp = serializers.DateTimeField(required=False, allow_null=True)

    end_timestamp = serializers.DateTimeField(required=False, allow_null=True)

    duration = serializers.IntegerField(required=False, allow_null=True, min_value=0)

            return Response(response, status.HTTP_400_BAD_REQUEST)

        data = serializer.validated_data

            user=request.user,

            summary=data['summary'],

            id=data.get('id'),

            end_timestamp=data.get('end_timestamp'),

            duration=data.get('duration')

        )

        return Response(response)

add = Add.as_view()

class Ack(GenericAPIView):

    permission_classes = (permissions.IsAuthenticated,)

        return Response({'err': 0})

ack = Ack.as_view()

    permission_classes = (permissions.IsAuthenticated,)

    def get(self, request, notification_id, *args, **kwargs):

        return Response({'err': 0})

forget = Forget.as_view()

from django.conf import settings

from django.db import models

from django.utils.translation import ugettext_lazy as _

from django.db.models import Q

from combo.data.models import CellBase

from combo.data.library import register_cell_class

        try:

            int(id)

        except (ValueError, TypeError):

            search_id = Q(external_id=id)

        else:

            search_id = Q(pk=id) | Q(external_id=id)

class Notification(models.Model):

    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)

    summary = models.CharField(_('Label'), max_length=140)

    class Meta:

        verbose_name = _('Notification')

    def __unicode__(self):

        return self.summary

    def public_id(self):

        return self.external_id or str(self.pk)

    @classmethod

        '''

        Create a new notification:

            Notification.notify(user, 'summary') -> id

        Renew an existing notification, or create a new one, with an external_id:

            Notification.notify(user, 'summary', id='id')

        '''

        if duration:

            if not isinstance(duration, timedelta):

                duration = timedelta(seconds=duration)

        else:

        else:

@register_cell_class

        extra_context = super(NotificationsCell, self).get_cell_extra_context(context)

        user = getattr(context.get('request'), 'user', None)

        if user and user.is_authenticated():

        return extra_context

    def get_badge(self, context):

        user = getattr(context.get('request'), 'user', None)

        if not user or not user.is_authenticated():

            return

            return

client = Client()

@pytest.fixture

def user():

    try:

    admin.save()

    return admin

@pytest.fixture

def user2():

    try:

        admin2 = User.objects.create_user('admin2', email=None, password='admin2')

    return admin2

def login(username='admin', password='admin'):

    resp = client.post('/login/', {'username': username, 'password': password})

    assert resp.status_code == 302

def test_notification_api(user, user2):

    assert created

    assert noti.end_timestamp - noti.start_timestamp == timedelta(seconds=3600)

    notification, created = Notification.notify(user, 'notibar', id='notibar')

    notification, created = Notification.notify(user, 'notirebar', id='notibar')

    assert not created

def test_notification_cell(user, user2):

    page = Page(title='notif', slug='test_notification_cell', template_name='standard')

    assert cell.is_visible(context['request'].user) is True

    assert cell.get_badge(context) is None

    content = cell.render(context)

    assert 'notibar' in content

    assert 'notifoo' in content

    assert cell.get_badge(context) == {'badge': '2'}

    content = cell.render(context)

    assert 'notibar' in content

    assert 'notifoo' not in content

    assert cell.get_badge(context) == {'badge': '1'}

    content = cell.render(context)

    assert 'notirebar' in content

    assert 'notibar' not in content

    content = cell.render(context)

    assert 'notiurl' in content

    assert 'https://www.example.net/' in content

    content = cell.render(context)

    assert 'acked' in content

    assert cell.get_badge(context) == {'badge': '1'}

    content = cell.render(context)

    assert cell.get_badge(context) is None

    assert 'notiother' in content

    assert cell.get_badge(context) == {'badge': '1'}

def test_notification_ws(user):

    def notify(data, check_id, count):

        result = json.loads(resp.content)

        assert result == {'data': {'id': check_id, 'created': True}, 'err': 0}

        assert Notification.objects.filter(user=user).count() == count

    login()

    notify({'summary': 'foo'}, '1', 1)

    resp = client.get(reverse('api-notification-ack', kwargs={'notification_id': '6'}))

    assert resp.status_code == 200

    assert Notification.objects.filter(acked=True).count() == 1

    resp = client.get(reverse('api-notification-forget', kwargs={'notification_id': '5'}))

    assert resp.status_code == 200

    assert Notification.objects.filter(acked=True).count() == 2

    assert notif.acked is True

    assert notif.end_timestamp < now()

def test_notification_ws_badrequest(user):

    def check_error(data, message):

    check_error({'summary': 'ok', 'duration': 4.01}, 'valid integer is required')

    check_error({'summary': 'ok', 'duration': -4}, 'greater than')

def test_notification_ws_deny():

    assert client.post(reverse('api-notification-add'),

                       json.dumps({'summary': 'ok'}),

    assert client.get(reverse('api-notification-forget',

                              kwargs={'notification_id': '1'})).status_code == 403

def test_notification_ws_check_urls():

    assert reverse('api-notification-add') == '/api/notification/add/'

    assert reverse('api-notification-ack',