Produits Entr'ouvert » Passerelle

                                '%s is unsupported' % (field, cls))

        instance.save()

        if 'log_level' in d:

            instance.set_log_level(d['log_level'])

        return instance

    def clean_logs(self):

        # clean logs

        ResourceLog.objects.filter(

                appname=self.get_connector_slug(),

                slug=self.slug,

                timestamp__lt=timestamp).delete()

    def check_status(self):

        # should raise an exception if status is not ok

        raise NotImplementedError

        help_text=_('Maximum HTTP request size to log'),

        default=settings.LOGGED_REQUESTS_MAX_SIZE

    )

    responses_max_size = models.PositiveIntegerField(

        verbose_name=_('Responses maximum size'),

        help_text=_('Maximum HTTP reponse size to log'),

        default=settings.LOGGED_RESPONSES_MAX_SIZE

    )

    class Meta:

        unique_together = (('resource_type', 'resource_pk'))

def parse_notification_delays(value):

    delays = [int(v.strip()) for v in value.split(',')]

    if not all(delay >= 0 for delay in delays):

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import datetime

import json

from dateutil import parser as date_parser

from django.contrib.contenttypes.models import ContentType

from django.core.urlresolvers import reverse

from django.core.exceptions import ObjectDoesNotExist, PermissionDenied

from django.db.models import Q

from django.forms import models as model_forms

from django.views.generic import (

    View, DetailView, ListView, CreateView, UpdateView, DeleteView, FormView)

from django.http import Http404, HttpResponse, HttpResponseRedirect

    def get_context_data(self, **kwargs):

        context = super(LoggingParametersUpdateView, self).get_context_data(**kwargs)

        context['connector'] = self.get_resource()

        return context

    def get_form_class(self):

        form_class = model_forms.modelform_factory(

            LoggingParameters,

        form_class.base_fields['trace_emails'].widget.attrs['rows'] = '3'

        return form_class

    def get_initial(self):

        d = self.initial.copy()

        d['resource_type'] = self.kwargs['resource_type']

        d['resource_pk'] = self.kwargs['resource_pk']

        parameters = self.get_resource().logging_parameters

        d['log_level'] = parameters.log_level

        d['trace_emails'] = parameters.trace_emails

        d['requests_max_size'] = parameters.requests_max_size

        d['responses_max_size'] = parameters.responses_max_size

        return d

    def get_resource(self):

        content_type = ContentType.objects.get_for_id(self.kwargs['resource_type'])

        return content_type.model_class().objects.get(pk=self.kwargs['resource_pk'])

    def get_success_url(self):

        return self.get_resource().get_absolute_url()

    def form_valid(self, form):

        parameters = self.get_resource().logging_parameters

        parameters.log_level = form.cleaned_data['log_level']

        parameters.trace_emails = form.cleaned_data['trace_emails']

        parameters.requests_max_size = form.cleaned_data['requests_max_size']

        parameters.responses_max_size = form.cleaned_data['responses_max_size']

        parameters.save()

        return super(LoggingParametersUpdateView, self).form_valid(form)

class ManageAvailabilityView(UpdateView):

    template_name = 'passerelle/manage/manage_availability_form.html'

    form_class = AvailabilityParametersForm

import datetime

import pytest

from mock import patch

from django.core.files import File

from django.db import connection

from django.db.migrations.executor import MigrationExecutor

from django.utils import timezone

from django.utils.six import StringIO

from passerelle.base.models import ResourceLog

from passerelle.apps.opengis.models import OpenGIS

from passerelle.apps.clicrdv.models import ClicRdv

def test_get_description_url_fields(db):

    connector = OpenGIS(slug='plop', wms_service_url='http://www.example.net')

    assert 'http://www.example.net' in [x[1] for x in connector.get_description_fields()]

    connector = OpenGIS(slug='plop', wms_service_url='http://username:secret@www.example.net')

    assert 'http://***:***@www.example.net' in [x[1] for x in connector.get_description_fields()]

def test_get_description_secret_fields(db):

    connector = ClicRdv(slug='plop', apikey='secret1', username='plop', password='secret2')

    assert not 'secret1' in [x[1] for x in connector.get_description_fields()]

    assert not 'secret2' in [x[1] for x in connector.get_description_fields()]

    ResourceLog.objects.all().delete()

    connector = OpenGIS(slug='plop', wms_service_url='http://www.example.net')

    connector.logger.error('hello1')

    connector.logger.error('hello2')

    assert ResourceLog.objects.all().count() == 2

    ResourceLog.objects.update(timestamp=timezone.now() - datetime.timedelta(days=10))

    connector.logger.error('hello3')

    assert ResourceLog.objects.all().count() == 3

    connector.daily()

    assert ResourceLog.objects.all().count() == 1

@pytest.fixture

def email_handler():

    import logging

    from django.utils.log import AdminEmailHandler