Produits Entr'ouvert » Combo

    def hourly(self):

        from combo.data.library import get_cell_classes

        from combo.data.models import CellBase

        cell_classes = [c for c in self.get_models() if c in get_cell_classes()]

        for cell in CellBase.get_cells(cell_filter=lambda x: x in cell_classes, page__snapshot__isnull=True):

            if hasattr(cell, 'check_validity'):

                cell.check_validity()

        validity_info = self.get_validity_info()

    def set_validity_from_url(

            self, resp,

            not_found_code='url_not_found', invalid_code='url_invalid',

            save=True):

        if resp is None:

            # can not retrieve data, don't report cell as invalid

            self.mark_as_valid(save=save)

        elif resp.status_code == 404:

            self.mark_as_invalid(not_found_code, save=save)

        elif 400 <= resp.status_code < 500:

            # 4xx error, cell is invalid

            self.mark_as_invalid(invalid_code, save=save)

        else:

            # 2xx or 3xx: cell is valid

            # 5xx error: can not retrieve data, don't report cell as invalid

            self.mark_as_valid(save=save)

    invalid_reason_codes = {

        'data_url_not_defined': _('No link set'),

        'data_url_not_found': _('URL seems to unexist'),

        'data_url_invalid': _('URL seems to be invalid'),

    }

    def save(self, *args, **kwargs):

        if 'update_fields' in kwargs:

            # don't check validity

            return super(LinkCell, self).save(*args, **kwargs)

        result = super(LinkCell, self).save(*args, **kwargs)

        # check validity

        self.check_validity()

        return result

    def get_url(self, context=None):

        context = context or {}

        if self.link_page:

            url = self.link_page.get_online_url()

        else:

            url = utils.get_templated_url(self.url, context=context)

        if self.anchor:

            url += '#' + self.anchor

        return url

        url = self.get_url(context)

        if render_skeleton and not urlparse.urlparse(url).netloc:

            url = request.build_absolute_uri(url)

        extra_context['url'] = url

    def check_validity(self):

        if self.link_page:

            self.mark_as_valid()

            return

        if not self.url:

            self.mark_as_invalid('data_url_not_defined')

            return

        resp = None

        try:

            resp = requests.get(self.get_url(), timeout=settings.REQUESTS_TIMEOUT)

            resp.raise_for_status()

        except (requests.exceptions.RequestException):

            pass

        self.set_validity_from_url(resp, not_found_code='data_url_not_found', invalid_code='data_url_invalid')

    invalid_reason_codes = {

        'data_link_invalid': _('Invalid link'),

    }

    def get_items(self, prefetch_validity_info=False):

            cell_filter=lambda x: hasattr(x, 'add_as_link_label'),

            prefetch_validity_info=prefetch_validity_info)

    def get_items_with_prefetch(self):

        return self.get_items(prefetch_validity_info=True)

    def check_validity(self):

        for link in self.get_items(prefetch_validity_info=True):

            validity_info = link.get_validity_info()

            if validity_info is not None:

                self.mark_as_invalid('data_link_invalid')

                return

        self.mark_as_valid()

    limit = models.PositiveSmallIntegerField(

        _('Maximum number of entries'),

        null=True, blank=True)

    invalid_reason_codes = {

        'data_url_not_defined': _('No URL set'),

        'data_url_not_found': _('URL seems to unexist'),

        'data_url_invalid': _('URL seems to be invalid'),

    }

        if not self.url:

            self.mark_as_invalid('data_url_not_defined')

            return extra_context

            feed_response = None

            self.set_validity_from_url(feed_response, not_found_code='data_url_not_found', invalid_code='data_url_invalid')

    invalid_reason_codes = {

        'data_url_not_found': _('URL seems to unexist'),

        'data_url_invalid': _('URL seems to be invalid'),

    }

                json_response = utils.requests.get(

                    url,

                    headers={'Accept': 'application/json'},

                    remote_service='auto',

                    cache_duration=data_url_dict.get('cache_duration', self.cache_duration),

                    without_user=True,

                    raise_if_not_cached=not(context.get('synchronous')),

                    invalidate_cache=invalidate_cache,

                    log_errors=log_errors,

                    timeout=data_url_dict.get('timeout', self.timeout),

                    django_request=context.get('request'),

                )

        if not self._meta.abstract:

            returns = [extra_context.get(d['key'] + '_status') for d in data_urls]

            returns = set([s for s in returns if s is not None])

            if returns and 200 not in returns:  # not a single valid answer

                if 404 in returns:

                    self.mark_as_invalid('data_url_not_found')

                elif any([400 <= r < 500 for r in returns]):

                    # at least 4xx errors, report the cell as invalid

                    self.mark_as_invalid('data_url_invalid')

                else:

                    # 2xx or 3xx: cell is valid

                    # 5xx error: can not retrieve data, don't report cell as invalid

                    self.mark_as_valid()

            else:

                self.mark_as_valid()

{% with cell.get_items_with_prefetch as links %}

   <span title="{{ link }}">

     {{ link|truncatechars:100 }}

     {% with link.get_invalid_reason as invalid_reason %}

     {% if invalid_reason %}

     <span class="invalid"><span class="invalid-icon"></span>{{ link.get_invalid_reason }}</span>

     {% endif %}

     {% endwith %}

   </span>

ul.list-of-links span.invalid,

div.cell h3 span.invalid,

ul.list-of-links span.invalid {

    invalid_cells = [c for c in invalid_cells if c.placeholder and not c.placeholder.startswith('_')]

        response = super(PageListCellAddLinkView, self).form_valid(form)

        self.cell.check_validity()

        return response

        self.cell.check_validity()

        self.cell.check_validity()

    cells = CellBase.get_cells(page=page, prefetch_validity_info=True)

    JsonCell, ConfigJsonCell, LinkListCell, FeedCell, ValidityInfo

from django.apps import apps

@pytest.fixture

def context():

    ctx = {'request': RequestFactory().get('/')}

    ctx['request'].user = None

    ctx['request'].session = {}

    return ctx

def test_link_cell_validity():

    page = Page.objects.create(title='example page', slug='example-page')

    cell = LinkCell.objects.create(

        page=page,

        title='Example Site',

        order=0,

    )

    # no link defined

    validity_info = ValidityInfo.objects.latest('pk')

    assert validity_info.invalid_reason_code == 'data_url_not_defined'

    assert validity_info.invalid_since is not None

    # internal link - no check

    cell.link_page = page

    with mock.patch('combo.data.models.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=404)

        requests_get.return_value = mock_json

        cell.save()

    assert requests_get.call_args_list == []

    assert ValidityInfo.objects.exists() is False

    # external link

    cell.link_page = None

    cell.url = 'http://example.net/'

    with mock.patch('combo.data.models.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=404)

        requests_get.return_value = mock_json

        cell.save()

    validity_info = ValidityInfo.objects.latest('pk')

    assert validity_info.invalid_reason_code == 'data_url_not_found'

    assert validity_info.invalid_since is not None

    with mock.patch('combo.data.models.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=200)

        requests_get.return_value = mock_json

        cell.save()

    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.data.models.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=500)

        requests_get.return_value = mock_json

        cell.save()

    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.data.models.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=400)

        requests_get.return_value = mock_json

        cell.save()

    validity_info = ValidityInfo.objects.latest('pk')

    assert validity_info.invalid_reason_code == 'data_url_invalid'

    assert validity_info.invalid_since is not None

def test_link_list_cell_validity():

    page = Page.objects.create(title='example page', slug='example-page')

    cell = LinkListCell.objects.create(order=0, page=page)

    item = LinkCell.objects.create(page=page, placeholder=cell.link_placeholder, order=0)

    item.mark_as_valid()

    cell.check_validity()

    assert ValidityInfo.objects.exists() is False

    item.mark_as_invalid('foo_bar_reason')

    cell.check_validity()

    validity_info = ValidityInfo.objects.latest('pk')

    assert validity_info.invalid_reason_code == 'data_link_invalid'

    assert validity_info.invalid_since is not None

def test_feed_cell_validity(context):

    page = Page.objects.create(title='example page', slug='example-page')

    cell = FeedCell.objects.create(page=page, placeholder='content', order=1)

    cell.get_cell_extra_context(context)

    validity_info = ValidityInfo.objects.latest('pk')

    assert validity_info.invalid_reason_code == 'data_url_not_defined'

    assert validity_info.invalid_since is not None

    cell.url = 'http://example.net/'

    cell.save()

    with mock.patch('combo.data.models.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=404)

        requests_get.return_value = mock_json

        cell.get_cell_extra_context(context)

    validity_info = ValidityInfo.objects.latest('pk')

    assert validity_info.invalid_reason_code == 'data_url_not_found'

    assert validity_info.invalid_since is not None

    with mock.patch('combo.data.models.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=200, content='')

        requests_get.return_value = mock_json

        cell.get_cell_extra_context(context)

    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.data.models.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=500)

        requests_get.return_value = mock_json

        cell.get_cell_extra_context(context)

    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.data.models.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=400)

        requests_get.return_value = mock_json

        cell.get_cell_extra_context(context)

    validity_info = ValidityInfo.objects.latest('pk')

    assert validity_info.invalid_reason_code == 'data_url_invalid'

    assert validity_info.invalid_since is not None

def test_json_cell_validity(context):

    page = Page.objects.create(title='example page', slug='example-page')

    cell = JsonCell.objects.create(

        page=page, placeholder='content', order=1,

        varnames_str='var1, var2, ',

        url='http://foo?varone=[var1]&vartwo=[var2]',

        template_string='/var1={{var1}}/var2={{var2}}/')

    with mock.patch('combo.data.models.requests.get') as requests_get:

        cell.get_cell_extra_context(context)

    assert requests_get.call_args_list == []  # invalid context

    assert ValidityInfo.objects.exists() is False

    context['var1'] = 'foo'

    context['var2'] = 'bar'

    context['synchronous'] = True  # to get fresh content

    with mock.patch('combo.utils.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=404)

        requests_get.side_effect = [mock_json]

        cell.get_cell_extra_context(context)

    validity_info = ValidityInfo.objects.latest('pk')

    assert validity_info.invalid_reason_code == 'data_url_not_found'

    assert validity_info.invalid_since is not None

    with mock.patch('combo.utils.requests.get') as requests_get:

        data = {'data': []}

        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)

        cell.get_cell_extra_context(context)

    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.utils.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=500)

        requests_get.return_value = mock_json

        cell.get_cell_extra_context(context)

    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.utils.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=400)

        requests_get.return_value = mock_json

        cell.get_cell_extra_context(context)

    validity_info = ValidityInfo.objects.latest('pk')

    assert validity_info.invalid_reason_code == 'data_url_invalid'

    assert validity_info.invalid_since is not None

def test_config_json_cell_validity(settings, context):

    settings.JSON_CELL_TYPES = {

        'test-config-json-cell': {

            'name': 'Foobar',

            'url': 'http://foo?varone=[var1]&vartwo=[var2]',

            'varnames': ['var1', 'var2']

        },

    }

    templates_settings = [settings.TEMPLATES[0].copy()]

    templates_settings[0]['DIRS'] = ['%s/templates-1' % os.path.abspath(os.path.dirname(__file__))]

    settings.TEMPLATES = templates_settings

    page = Page.objects.create(title='example page', slug='example-page')

    cell = ConfigJsonCell.objects.create(

        page=page, placeholder='content', order=1,

        key='test-config-json-cell',

        parameters={'identifier': 'plop'})

    assert cell.varnames == ['var1', 'var2']

    with mock.patch('combo.data.models.requests.get') as requests_get:

        cell.get_cell_extra_context(context)

    assert requests_get.call_args_list == []  # invalid context

    assert ValidityInfo.objects.exists() is False

    context['var1'] = 'foo'

    context['var2'] = 'bar'

    context['synchronous'] = True  # to get fresh content

    with mock.patch('combo.utils.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=404)

        requests_get.side_effect = [mock_json]

        cell.get_cell_extra_context(context)

    validity_info = ValidityInfo.objects.latest('pk')

    assert validity_info.invalid_reason_code == 'data_url_not_found'

    assert validity_info.invalid_since is not None

    with mock.patch('combo.utils.requests.get') as requests_get:

        data = {'data': []}

        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)

        cell.get_cell_extra_context(context)

    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.utils.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=500)

        requests_get.return_value = mock_json

        cell.get_cell_extra_context(context)

    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.utils.requests.get') as requests_get:

        mock_json = mock.Mock(status_code=400)

        requests_get.return_value = mock_json

        cell.get_cell_extra_context(context)

    validity_info = ValidityInfo.objects.latest('pk')

    assert validity_info.invalid_reason_code == 'data_url_invalid'

    assert validity_info.invalid_since is not None

def test_hourly():

    appconfig = apps.get_app_config('data')

    page = Page.objects.create(title='xxx', slug='test_current_forms_cell_render', template_name='standard')

    cell_classes = [c for c in appconfig.get_models() if c in get_cell_classes()]

    for klass in cell_classes:

        klass.objects.create(page=page, placeholder='content', order=0)

    for klass in cell_classes:

        if klass in [LinkCell, LinkListCell]:

            with mock.patch('combo.data.models.%s.check_validity' % klass.__name__) as check_validity:

                appconfig.hourly()

            assert check_validity.call_args_list == [mock.call()]

        else:

            assert hasattr(klass, 'check_validity') is False

    cell2 = LinkListCell.objects.create(order=0, placeholder='content', page=page)

    item = LinkCell.objects.create(page=page, placeholder=cell2.link_placeholder, order=0)

    item.mark_as_invalid('foo_bar_reason')

    cell2.check_validity()

    resp = app.get('/manage/pages/%s/' % page.pk)

    assert '<span class="invalid"><span class="invalid-icon"></span>Invalid link</span>' in resp.text

    assert '<span class="invalid"><span class="invalid-icon"></span>foo_bar_reason</span>' in resp.text

        assert len(ctx.captured_queries) == 31

    # cells from snapshot are not reported

    # cells used in LinkListCell are not reported

    page.snapshot = None

    page.save()

    cell2 = LinkListCell.objects.create(order=0, placeholder='content', page=page)

    item = LinkCell.objects.create(page=page, placeholder=cell2.link_placeholder, order=0)

    item.mark_as_invalid('foo_bar_reason')

    resp = app.get('/manage/cells/invalid-report/')

    assert resp.context['object_list'] == [cell]

        # +2 for validity info of parent page

        assert queries_count_third == queries_count_second + 2

        assert queries_count_fourth == queries_count_second + 2 + 1