Produits Entr'ouvert » Combo

        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()

invalid_reason_codes = {

    'wcs_form_not_defined': _('No form set'),

    'wcs_form_not_found': _('Invalid form'),

    'wcs_category_not_defined': _('No category set'),

    'wcs_category_not_found': _('Invalid category'),

    'wcs_data_failure': _('Failed to get data'),

}

    invalid_reason_codes = invalid_reason_codes

        if 'update_fields' in kwargs:

            # don't populate the cache

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

        def populate_cache():

            if self.formdef_reference:

                wcs_key, form_slug = self.formdef_reference.split(':')

                wcs_site = get_wcs_services().get(wcs_key)

                forms_response_json = get_wcs_json(wcs_site, 'api/formdefs/')

                if not forms_response_json:

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

                    self.mark_as_valid()

                    return

                if isinstance(forms_response_json, dict):

                    # forward compability with future w.c.s. API

                    forms_response_json = forms_response_json.get('data')

                form_found = False

                for form in forms_response_json or []:

                    slug = form.get('slug')

                    if slug == form_slug:

                        self.cached_title = form.get('title')

                        self.cached_url = form.get('url')

                        self.cached_json = form

                        form_found = True

                        break

                if form_found:

                    self.mark_as_valid()

                    return

                else:

                    return self.mark_as_invalid('wcs_form_not_found', save=False)

            else:

                return self.mark_as_invalid('wcs_form_not_defined', save=False)

        validity_info = populate_cache()

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

        if validity_info:

            # save validity_info after Cell insert

            validity_info.content_object = self

            validity_info.save()

        return result

    invalid_reason_codes = invalid_reason_codes

        if 'update_fields' in kwargs:

            # don't populate the cache

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

        def populate_cache():

            if self.category_reference:

                wcs_key, category_slug = self.category_reference.split(':')

                wcs_site = get_wcs_services().get(wcs_key)

                categories_response_json = get_wcs_json(wcs_site, 'api/categories/')

                if not categories_response_json:

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

                    self.mark_as_valid()

                    return

                category_found = False

                for category in categories_response_json.get('data', []):

                    slug = category.get('slug')

                    if slug == category_slug:

                        self.cached_title = category.get('title')

                        self.cached_description = category.get('description') or ''

                        self.cached_url = category.get('url')

                        category_found = True

                        break

                if category_found:

                    self.mark_as_valid()

                    return

                else:

                    return self.mark_as_invalid('wcs_category_not_found', save=False)

            else:

                return self.mark_as_invalid('wcs_category_not_defined', save=False)

        validity_info = populate_cache()

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

        if validity_info:

            # save validity_info after Cell insert

            validity_info.content_object = self

            validity_info.save()

        return result

    warn_on_4xx = True

    invalid_reason_codes = invalid_reason_codes

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

            logging.debug('failed to get data from any %s (%r)', api_url, returns)

            if all([400 <= r < 500 for r in returns]) and self.warn_on_4xx:

                # only 4xx errors, not a user cell, report the cell as invalid

                self.mark_as_invalid('wcs_data_failure', force=False)

            else:

                self.mark_as_valid()

        else:

            self.mark_as_valid()

    warn_on_4xx = False

class CategoriesValidityMixin(object):

    def check_validity(self):

        categories = self.categories.get('data', [])

        if not categories:

            return

        for category_reference in categories:

            wcs_key, category_slug = category_reference.split(':')

            wcs_site = get_wcs_services().get(wcs_key)

            categories_response_json = get_wcs_json(wcs_site, 'api/categories/')

            if not categories_response_json:

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

                continue

            category_found = any(

                [c.get('slug') == category_slug

                 for c in categories_response_json.get('data', [])])

            if not category_found:

                self.mark_as_invalid('wcs_category_not_found')

                return

        self.mark_as_valid()

class WcsCurrentFormsCell(WcsUserDataBaseCell, CategoriesValidityMixin):

class WcsCurrentDraftsCell(WcsUserDataBaseCell, CategoriesValidityMixin):

from combo.data.library import get_cell_classes

from combo.data.models import CellBase, LinkListCell, Page, ValidityInfo

@wcs_present

def test_form_cell_validity():

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

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

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

    assert validity_info.invalid_reason_code == 'wcs_form_not_defined'

    assert validity_info.invalid_since is not None

    cell.formdef_reference = u'default:form-title'

    cell.save()

    assert ValidityInfo.objects.exists() is False

    # can not retrieve formdefs, don't set cell as invalid

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

        mock_json = mock.Mock(status_code=404)

        requests_get.return_value = mock_json

        cell.save()

    assert ValidityInfo.objects.exists() is False

    cell.formdef_reference = u'default:foobar'

    cell.save()

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

    assert validity_info.invalid_reason_code == 'wcs_form_not_found'

    assert validity_info.invalid_since is not None

@wcs_present

def test_category_cell_validity():

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

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

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

    assert validity_info.invalid_reason_code == 'wcs_category_not_defined'

    assert validity_info.invalid_since is not None

    cell.category_reference = u'default:test-3'

    cell.save()

    assert ValidityInfo.objects.exists() is False

    # can not retrieve categories, don't set cell as invalid

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

        mock_json = mock.Mock(status_code=404)

        requests_get.return_value = mock_json

        cell.save()

    assert ValidityInfo.objects.exists() is False

    cell.category_reference = 'default:foobar'

    cell.save()

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

    assert validity_info.invalid_reason_code == 'wcs_category_not_found'

    assert validity_info.invalid_since is not None

        mock_json = mock.Mock(status_code=200)

        requests_get.return_value = mock_json

        mock_json = mock.Mock(status_code=200)

        requests_get.return_value = mock_json

@wcs_present

def test_current_forms_cell_validity(context):

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

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

    context['request'].user = MockUser()

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

    cell.get_data(context)

    assert ValidityInfo.objects.exists() is False

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

        mock_json = mock.Mock(status_code=404)

        requests_get.return_value = mock_json

        cell.get_data(context)

    assert ValidityInfo.objects.exists() is False

@wcs_present

def test_current_forms_cell_check_validity(context):

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

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

    # no category

    cell.check_validity()

    assert ValidityInfo.objects.exists() is False

    # valid categories

    cell.categories = {'data': ['default:test-3', 'default:test-9']}

    cell.save()

    cell.check_validity()

    assert ValidityInfo.objects.exists() is False

    # can not retrieve categories, don't set cell as invalid

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

        mock_json = mock.Mock(status_code=404)

        requests_get.return_value = mock_json

        cell.check_validity()

    assert ValidityInfo.objects.exists() is False

    # invalid category

    cell.categories = {'data': ['default:foobar', 'default:test-9']}

    cell.save()

    cell.check_validity()

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

    assert validity_info.invalid_reason_code == 'wcs_category_not_found'

    assert validity_info.invalid_since is not None

@wcs_present

def test_care_forms_cell_validity(context):

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

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

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

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

        mock_json = mock.Mock(status_code=200)

        requests_get.return_value = mock_json

        cell.get_data(context)

    assert ValidityInfo.objects.exists() is False

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

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

        mock_json = mock.Mock(status_code=500)

        requests_get.return_value = mock_json

        cell.get_data(context)

    assert ValidityInfo.objects.exists() is False

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

        mock_json = mock.Mock(status_code=404)

        requests_get.return_value = mock_json

        cell.get_data(context)

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

    assert validity_info.invalid_reason_code == 'wcs_data_failure'

    assert validity_info.invalid_since is not None

@wcs_present

def test_forms_of_category_cell_validity(context):

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

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

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

    assert validity_info.invalid_reason_code == 'wcs_category_not_defined'

    assert validity_info.invalid_since is not None

    cell.category_reference = 'default:test-9'

    cell.save()

    assert ValidityInfo.objects.exists() is False

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

        mock_json = mock.Mock(status_code=404)

        requests_get.return_value = mock_json

        cell.render(context)

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

    assert validity_info.invalid_reason_code == 'wcs_data_failure'

    assert validity_info.invalid_since is not None

    cell.mark_as_valid()

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

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

        mock_json = mock.Mock(status_code=500)

        requests_get.return_value = mock_json

        cell.render(context)

    assert ValidityInfo.objects.exists() is False

    # can not retrieve categories, don't set cell as invalid

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

        mock_json = mock.Mock(status_code=404)

        requests_get.return_value = mock_json

        cell.save()

    assert ValidityInfo.objects.exists() is False

    cell.category_reference = 'default:foobar'

    cell.save()

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

    assert validity_info.invalid_reason_code == 'wcs_category_not_found'

    assert validity_info.invalid_since is not None

@wcs_present

def test_current_drafts_cell_check_validity(context):

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

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

    # no category

    cell.check_validity()

    assert ValidityInfo.objects.exists() is False

    # valid categories

    cell.categories = {'data': ['default:test-3', 'default:test-9']}

    cell.save()

    cell.check_validity()

    assert ValidityInfo.objects.exists() is False

    # can not retrieve vategories, don't set cell as invalid

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

        mock_json = mock.Mock(status_code=404)

        requests_get.return_value = mock_json

        cell.check_validity()

    assert ValidityInfo.objects.exists() is False

    # invalid category

    cell.categories = {'data': ['default:foobar', 'default:test-9']}

    cell.save()

    cell.check_validity()

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

    assert validity_info.invalid_reason_code == 'wcs_category_not_found'

    assert validity_info.invalid_since is not None

@wcs_present

@wcs_present

def test_hourly():

    appconfig = apps.get_app_config('wcs')

    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 [WcsCurrentFormsCell, WcsCurrentDraftsCell]:

            with mock.patch('combo.apps.wcs.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