Produits Entr'ouvert » Combo

        from .models import (

            WcsCardInfosCell,

            WcsCardsCell,

            WcsCategoryCell,

            WcsFormCell,

            WcsFormsOfCategoryCell,

        )

            WcsCardsCell,

            WcsCardInfosCell,

    WcsCardInfosCell,

    WcsCardsCell,

class WcsCardsCellForm(forms.ModelForm):

    with_user = forms.BooleanField(

        label=_('Restrict to cards accessible to the user'), required=False, initial=True

    )

    class Meta:

        model = WcsCardsCell

        fields = ('carddef_reference', 'limit', 'only_for_user')

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

        instance = kwargs['instance']

        initial = kwargs.pop('initial', {})

        initial['with_user'] = not instance.without_user

        super().__init__(initial=initial, *args, **kwargs)

        card_models = get_wcs_options('/api/cards/@list', include_custom_views=True)

        self.fields['carddef_reference'].widget = forms.Select(choices=card_models)

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

        super().save(*args, **kwargs)

        self.instance.without_user = not self.cleaned_data['with_user']

        self.instance.save()

        return self.instance

class WcsCardInfoCellForm(forms.ModelForm):

        model = WcsCardInfosCell

class WcsCardInfoCellAppearanceBaseForm(forms.ModelForm):

class WcsCardInfoCellDisplayForm(forms.ModelForm):

        model = WcsCardInfosCell

@register_cell_class

class WcsCardsCell(CardMixin, WcsBlurpMixin, CellBase):

    carddef_reference = models.CharField(_('Card Model'), max_length=150)

    cached_title = models.CharField(_('Title'), max_length=150)

    custom_title = models.CharField(_('Custom Title'), max_length=150, blank=True)

    only_for_user = models.BooleanField(_('Limit to cards linked to the logged-in user'), default=False)

    without_user = models.BooleanField(_('Ignore the logged-in user'), default=False)

    limit = models.PositiveSmallIntegerField(

        _('Number of cards per page (default 10)'), null=True, blank=True

    )

    default_template_name = 'combo/wcs/cards.html'

    variable_name = 'card_objects'

    class Meta:

        verbose_name = _('Cards')

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

        super().save(*args, **kwargs)

        if 'update_fields' in kwargs:

            # don't populate the cache

            return

        def populate_cache():

            if self.carddef_reference:

                parts = self.carddef_reference.split(':')

                wcs_key, card_slug = parts[:2]

                wcs_site = get_wcs_services().get(wcs_key)

                card_models = get_wcs_json(wcs_site, 'api/cards/@list')

                if not card_models or card_models.get('err') == 1:

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

                    self.mark_as_valid()

                    return

                card_found = False

                for card in card_models.get('data') or []:

                    slug = card['slug']

                    if slug != card_slug:

                        continue

                    card_title = card['title']

                    if len(parts) > 2:

                        custom_view = None

                        for v in card.get('custom_views') or []:

                            if v['id'] == parts[2]:

                                custom_view = v

                                break

                        if custom_view is None:

                            continue

                        card_title = '%s - %s' % (card_title, custom_view['text'])

                    self.cached_title = card_title

                    self.save(update_fields=['cached_title'])

                    card_found = True

                    break

                if card_found:

                    self.mark_as_valid()

                    return

                else:

                    return self.mark_as_invalid('wcs_card_not_found')

            else:

                return self.mark_as_invalid('wcs_card_not_defined')

        populate_cache()

    def is_visible(self, request, **kwargs):

        user = getattr(request, 'user', None)

        if self.only_for_user and (not user or user.is_anonymous):

            return False

        return super().is_visible(request, **kwargs)

    def get_api_url(self, context):

        parts = self.carddef_reference.split(':')

        url = '/api/cards/%s/list' % parts[1]

        if len(parts) > 2:

            url = '%s/%s' % (url, parts[2])

        user = self.get_concerned_user(context)

        if self.only_for_user and user and not user.is_anonymous and user.get_name_id():

            url = '%s?filter-user-uuid=%s' % (url, user.get_name_id())

        return url

    def get_cell_extra_context(self, context):

        extra_context = super().get_cell_extra_context(context)

        extra_context['paginate_by'] = self.limit or 10

        extra_context['title'] = self.custom_title or self.cached_title

        pages_with_sub_slug = Page.objects.exclude(sub_slug='')

        card_id = '%s_id' % self.carddef_reference.split(':')[1]

        matching_pages = [

            p for p in pages_with_sub_slug if '<%s>' % card_id in p.sub_slug or p.sub_slug == card_id

        ]

        if matching_pages:

            card_page = matching_pages[0]

            extra_context['card_page_base_url'] = card_page.get_online_url()

        try:

            extra_context['card_objects'] = list(extra_context['card_objects'][self.wcs_site]['data'])

        except (KeyError, TypeError):

            # an error occured when getting the data

            extra_context['card_objects'] = []

        return extra_context

    def get_default_form_class(self):

        from .forms import WcsCardsCellForm

        return WcsCardsCellForm

    def render_for_search(self):

        return ''

    class Meta:

        verbose_name = _('Card(s)')

@register_cell_class

class WcsCardInfosCell(CardMixin, CellBase):

    carddef_reference = models.CharField(_('Card Model'), max_length=150)

    related_card_path = models.CharField(_('Card Identifier'), max_length=1000, blank=True)

    card_ids = models.CharField(_('Other Card Identifiers'), max_length=1000, blank=True)

    only_for_user = models.BooleanField(_('Limit to cards linked to the logged-in user'), default=False)

    without_user = models.BooleanField(_('Ignore the logged-in user'), default=False)

    limit = models.PositiveSmallIntegerField(

        _('Number of cards per page (default 10)'), null=True, blank=True

    )

    custom_schema = JSONField(blank=True, default=dict)

    display_mode = models.CharField(

        _('Display mode'),

        max_length=10,

        default='card',

        choices=[

            ('card', _('Card')),

            ('table', _('Table')),

        ],

    )

    title_type = models.CharField(

        _('Title'),

        max_length=20,

        default='auto',

        blank=False,

        choices=[

            ('auto', _('Default Title (Card Label)')),

            ('manual', _('Custom Title')),

            ('empty', _('No Title')),

        ],

    )

    custom_title = models.CharField(_('Custom Title'), max_length=150, blank=True)

    cached_title = models.CharField(_('Title'), max_length=150)

    cached_json = JSONField(blank=True, default=dict)

    manager_appearance_template = 'combo/wcs/manager/card-infos-cell-form-appearance.html'

        verbose_name = _('Card Information Cell')

        for cell in WcsCardInfosCell.objects.filter(page=self.page_id).exclude(pk=self.pk):

            first_cell = WcsCardInfosCell.objects.get(page=self.page_id, slug=first_cell_slug)

        except (WcsCardInfosCell.DoesNotExist, WcsCardInfosCell.MultipleObjectsReturned):

        from .forms import WcsCardInfoCellForm

        return WcsCardInfoCellForm

        from .forms import WcsCardInfoCellAppearanceBaseForm

        return super().get_appearance_form_class(base_options_form_class=WcsCardInfoCellAppearanceBaseForm)

        from .forms import WcsCardInfoCellDisplayForm

                'template': 'combo/wcs/manager/card-infos-cell-form-display.html',

                'form': WcsCardInfoCellDisplayForm,

            # for legacy: card cell with table mode should use assets of old cards cell

        return super().get_asset_slot_key(key)

        if self.display_mode == 'table' and settings.COMBO_CELL_ASSET_SLOTS.get('wcs_wcscardscell'):

            # for legacy: card cell with table mode should use assets of old cards cell

            return settings.COMBO_CELL_ASSET_SLOTS['wcs_wcscardscell']

        return super().get_asset_slot_templates()

  $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-display_mode').on('change', function() {

      $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-customize_display').parent().show();

      if ($('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-customize_display').val()) {

        $('.wcs-cards-cell--grid', $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-customize_display').parents('.cell')).show();

      $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-customize_display').parent().hide();

      $('.wcs-cards-cell--grid', $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-customize_display').parents('.cell')).hide();

  $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-display_mode').change();

{% extends "combo/cell_appearance.html" %}

{% block cell-form-appearance %}

  {{ block.super }}

  <script>

    {# display/hide custom_title field #}

    $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-title_type').on('change', function() {

      if ($(this).val() == 'manual') {

        $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-custom_title').parent().show();

      } else {

        $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-custom_title').parent().hide();

      }

    });

    $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-title_type').change();

    {# display/hide card_ids field #}

    $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-related_card_path').on('change', function() {

      if (!$(this).val()) {

        $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-card_ids').parent().show();

      } else {

        $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-card_ids').parent().hide();

      }

    });

    $('#id_cwcs_wcscardinfoscell-{{ cell.pk }}-related_card_path').change();

  </script>

{% endblock %}

// UI to customize the layout of the content of a wcs-card-infos-cell

  $('.wcs-card-infos-cell').each(function(i, el) {

        assert len(ctx.captured_queries) in [314, 315]

        assert len(ctx.captured_queries) == 282

        assert len(ctx.captured_queries) == 72

        assert len(ctx.captured_queries) == 157

        assert len(ctx.captured_queries) in (176, 226)  # (3.2, 2.2)

    WcsCardInfosCell,

    WcsCardsCell,

@mock.patch('requests.Session.send', side_effect=mocked_requests_send)

def test_manager_cards_cell(mock_send, app, admin_user):

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

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

    app = login(app)

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

    assert ('data-cell-reference="%s"' % cell.get_reference()) in resp.text

    assert cell.without_user is False

    assert resp.forms[0]['c%s-with_user' % cell.get_reference()].value == 'on'

    resp.forms[0]['c%s-with_user' % cell.get_reference()].value = False

    manager_submit_cell(resp.forms[0])

    cell.refresh_from_db()

    assert cell.without_user is True

    assert resp.forms[0]['c%s-with_user' % cell.get_reference()].value is None

def test_manager_cards_cell_tabs(app, admin_user):

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

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

    login(app)

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

    assert not resp.pyquery('[data-tab-slug="general"] input[name$="custom_title"]')

    assert not resp.pyquery('#tab-%s-general.pk-tabs--button-marker' % cell.get_reference())

    assert resp.pyquery('[data-tab-slug="appearance"] input[name$="custom_title"]')

@mock.patch('requests.Session.send', side_effect=mocked_requests_send)

def test_cards_cell_setup(mock_send):

    cell = WcsCardsCell()

    form_class = cell.get_default_form_class()

    form = form_class(instance=cell)

    assert form.fields['carddef_reference'].widget.choices == [

        ('default:card_model_1', 'test : Card Model 1'),

        ('default:card_model_1:foo', 'test : Card Model 1 - bar'),

        ('default:card_model_2', 'test : Card Model 2'),

        ('default:card_model_3', 'test : Card Model 3'),

        ('default:card_a', 'test : Card A'),

        ('default:card_b', 'test : Card B'),

        ('default:card_b:a-custom-view', 'test : Card B - foo bar'),

        ('default:card_c', 'test : Card C'),

        ('default:card_d', 'test : Card D'),

        ('default:card_e', 'test : Card E'),

        ('other:card_model_1', 'test2 : Card Model 1'),

        ('other:card_model_1:foo', 'test2 : Card Model 1 - bar'),

        ('other:card_model_2', 'test2 : Card Model 2'),

        ('other:card_model_3', 'test2 : Card Model 3'),

        ('other:card_a', 'test2 : Card A'),

        ('other:card_b', 'test2 : Card B'),

        ('other:card_b:a-custom-view', 'test2 : Card B - foo bar'),

        ('other:card_c', 'test2 : Card C'),

        ('other:card_d', 'test2 : Card D'),

        ('other:card_e', 'test2 : Card E'),

    ]

@mock.patch('requests.Session.send', side_effect=mocked_requests_send)

def test_cards_cell_save_cache(mock_send):

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

    cell = WcsCardsCell(page=page, placeholder='content', order=0)

    assert cell.get_additional_label() is None

    cell.carddef_reference = 'default:card_model_1'

    cell.save()

    assert cell.cached_title == 'Card Model 1'

    assert cell.get_additional_label() == 'Card Model 1'

    # make sure cached attributes are removed from serialized pages

    assert 'cached_' not in json.dumps(page.get_serialized_page())

    cell.carddef_reference = 'default:card_model_1:foo'

    cell.save()

    assert cell.cached_title == 'Card Model 1 - bar'

    assert cell.get_additional_label() == 'Card Model 1 - bar'

    # check content provided to search engine

    assert cell.render_for_search() == ''

    # artificially change title

    WcsCardsCell.objects.filter(pk=cell.pk).update(cached_title='XXX')

    assert WcsCardsCell.objects.get(pk=cell.pk).cached_title == 'XXX'

    # run update db cache

    appconfig = apps.get_app_config('wcs')

    appconfig.update_db_cache()

    assert WcsCardsCell.objects.get(pk=cell.pk).cached_title == 'Card Model 1 - bar'

@mock.patch('requests.Session.send', side_effect=mocked_requests_send)

def test_cards_cell_validity(mock_send):

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

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

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

    assert validity_info.invalid_reason_code == 'wcs_card_not_defined'

    assert validity_info.invalid_since is not None

    cell.carddef_reference = 'default:card_model_1'

    cell.save()

    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_resp = Response()

        mock_resp.status_code = 500

        requests_get.return_value = mock_resp

        cell.save()

    assert ValidityInfo.objects.exists() is False

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

        requests_get.side_effect = ConnectionError()

        cell.save()

    assert ValidityInfo.objects.exists() is False

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

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

        mock_resp = Response()

        mock_resp.status_code = 404

        requests_get.return_value = mock_resp

        cell.save()

    assert ValidityInfo.objects.exists() is False

    cell.carddef_reference = 'default:foobar'

    cell.save()

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

    assert validity_info.invalid_reason_code == 'wcs_card_not_found'

    assert validity_info.invalid_since is not None

    cell.carddef_reference = 'default:card_model_1:foo'

    cell.save()

    assert ValidityInfo.objects.exists() is False

    cell.carddef_reference = 'default:card_model_1:bar'

    cell.save()

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

    assert validity_info.invalid_reason_code == 'wcs_card_not_found'

    assert validity_info.invalid_since is not None

@mock.patch('requests.Session.send', side_effect=mocked_requests_send)

def test_cards_cell_load(mock_send):

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

    cell = WcsCardsCell(page=page, placeholder='content', order=0)

    cell.carddef_reference = 'default:card_model_1'

    cell.save()

    site_export = [page.get_serialized_page()]

    cell.delete()

    assert not Page.objects.get(pk=page.pk).get_cells()

    Page.load_serialized_pages(site_export)

    page = Page.objects.get(slug='test_cards')

    cells = page.get_cells()

    assert len(cells) == 1

    cell = cells[0]

    assert cell.cached_title == 'Card Model 1'

    cell.carddef_reference = 'default:card_model_1:foo'

    cell.save()

    site_export = [page.get_serialized_page()]

    cell.delete()

    assert not Page.objects.get(pk=page.pk).get_cells()

    Page.load_serialized_pages(site_export)

    page = Page.objects.get(slug='test_cards')

    cells = page.get_cells()

    assert len(cells) == 1

    cell = cells[0]

    assert cell.cached_title == 'Card Model 1 - bar'

@mock.patch('requests.Session.send', side_effect=mocked_requests_send)

def test_cards_cell_render(mock_send, context):

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

    cell = WcsCardsCell(page=page, placeholder='content', order=0)

    cell.carddef_reference = 'default:card_model_1'

    cell.save()

    # query should fail as nothing is cached

    cache.clear()

    with pytest.raises(NothingInCacheException):

        result = cell.render(context)

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

    context['cell'] = cell

    result = cell.render(context)

    assert '<h2>Card Model 1</h2>' in result

    assert 'cards-card_model_1' in result

    assert (

        '<a href="http://127.0.0.1:8999/backoffice/data/card_model_1/11/"><span class="card-title">aa</span></a>'

        in result

    )

    assert (

        '<a href="http://127.0.0.1:8999/backoffice/data/card_model_1/12/"><span class="card-title">bb</span></a>'

        in result

    )

    assert (

        '<a href="http://127.0.0.1:8999/backoffice/data/card_model_1/13/"><span class="card-title">cc</span></a>'

        in result

    )

    assert 'data-paginate-by="10"' in result

    # create a page with the correct subslug

    page = Page.objects.create(slug='foo', title='Foo', sub_slug='(?P<card_model_1_id>[a-z0-9]+)')

    result = cell.render(context)

    assert '<h2>Card Model 1</h2>' in result

    assert '<a href="/foo/11"><span class="card-title">aa</span></a>' in result

    assert '<a href="/foo/12"><span class="card-title">bb</span></a>' in result

    assert '<a href="/foo/13"><span class="card-title">cc</span></a>' in result

    cell.carddef_reference = 'default:card_model_1:foo'

    cell.limit = 42

    cell.save()

    page.sub_slug = 'card_model_1_id'

    page.save()

    result = cell.render(context)

    assert '<h2>Card Model 1 - bar</h2>' in result

    assert '<a href="/foo/11"><span class="card-title">aa</span></a>' in result

    assert '<a href="/foo/12"><span class="card-title">bb</span></a>' in result

    assert '<a href="/foo/13"><span class="card-title">cc</span></a>' not in result

    assert 'data-paginate-by="42"' in result

    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.render(context)

    assert len(requests_get.call_args_list) == 1

    assert requests_get.call_args_list[0][0][0] == '/api/cards/card_model_1/list/foo'

    assert requests_get.call_args_list[0][1]['remote_service']['url'] == 'http://127.0.0.1:8999/'

    cell.custom_title = 'Foo bar'

    cell.save()

    result = cell.render(context)

    assert '<h2>Card Model 1 - bar</h2>' not in result

    assert '<h2>Foo bar</h2>' in result

@mock.patch('requests.Session.send', side_effect=mocked_requests_send)

def test_cards_cell_only_for_user(mock_send, context):

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

    cell = WcsCardsCell(page=page, placeholder='content', order=0)

    cell.carddef_reference = 'default:card_model_1'

    cell.only_for_user = False

    cell.save()

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

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

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

    cell.only_for_user = True

    cell.save()

    context['request'].user = None

    assert cell.is_visible(request=context['request']) is False

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

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

    cache.clear()

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

    context['request'].user = None

    mock_send.reset_mock()

    cell.render(context)

    assert 'filter-user-uuid' not in mock_send.call_args_list[0][0][0].url

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

    mock_send.reset_mock()

    cell.render(context)

    assert 'filter-user-uuid' not in mock_send.call_args_list[0][0][0].url

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

    mock_send.reset_mock()

    cell.render(context)

    assert 'filter-user-uuid=xyz' in mock_send.call_args_list[0][0][0].url

@mock.patch('requests.Session.send', side_effect=mocked_requests_send)

def test_cards_cell_render_user(mock_send, context, nocache):

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

    cell = WcsCardsCell(page=page, placeholder='content', order=0)

    cell.carddef_reference = 'default:card_model_1'

    cell.save()

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

    assert context['request'].user is None

    mock_send.reset_mock()

    cell.render(context)

    assert 'NameID=&' in mock_send.call_args_list[0][0][0].url

    assert 'email=&' in mock_send.call_args_list[0][0][0].url

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

    mock_send.reset_mock()

    cell.render(context)

    assert 'NameID=&' in mock_send.call_args_list[0][0][0].url

    assert 'email=&' in mock_send.call_args_list[0][0][0].url

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

    mock_send.reset_mock()

    cell.render(context)

    assert 'email=foo%40example.net' in mock_send.call_args_list[0][0][0].url

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

    mock_send.reset_mock()

    cell.render(context)

    assert 'NameID=xyz' in mock_send.call_args_list[0][0][0].url

    cell.without_user = True

    cell.save()

    context['request'].user = None

    mock_send.reset_mock()

    cell.render(context)

    assert 'NameID' not in mock_send.call_args_list[0][0][0].url

    assert 'email' not in mock_send.call_args_list[0][0][0].url

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

    mock_send.reset_mock()

    cell.render(context)

    assert 'NameID' not in mock_send.call_args_list[0][0][0].url

    assert 'email' not in mock_send.call_args_list[0][0][0].url

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

    mock_send.reset_mock()

    cell.render(context)

    assert 'NameID' not in mock_send.call_args_list[0][0][0].url

    assert 'email' not in mock_send.call_args_list[0][0][0].url

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

    mock_send.reset_mock()

    cell.render(context)

    assert 'NameID' not in mock_send.call_args_list[0][0][0].url

    assert 'email' not in mock_send.call_args_list[0][0][0].url

            WcsCardInfosCell,

from combo.apps.wcs.forms import WcsCardInfoCellDisplayForm

from combo.apps.wcs.models import WcsCardInfosCell

    cell = WcsCardInfosCell(page=page, placeholder='content', order=0)

    form_display = WcsCardInfoCellDisplayForm(instance=cell)

    form_display = WcsCardInfoCellDisplayForm(instance=cell)

    form_display = WcsCardInfoCellDisplayForm(instance=cell)

    form_display = WcsCardInfoCellDisplayForm(instance=cell)

    WcsCardInfosCell.objects.all().delete()

    cell_add_url = [x for x in resp.html.find_all('option') if x.text == 'Card Information Cell'][0].get(

        'data-add-url'

    )

    cell = WcsCardInfosCell.objects.all().first()

    cell = WcsCardInfosCell()

    cell = WcsCardInfosCell(page=page, placeholder='content', order=0)

    WcsCardInfosCell.objects.filter(pk=cell.pk).update(cached_title='XXX', cached_json={})

    assert WcsCardInfosCell.objects.get(pk=cell.pk).cached_title == 'XXX'

    assert WcsCardInfosCell.objects.get(pk=cell.pk).cached_json == {}

    assert WcsCardInfosCell.objects.get(pk=cell.pk).cached_title == 'Card Model 1'

    assert WcsCardInfosCell.objects.get(pk=cell.pk).cached_json != {}

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

    cell = WcsCardInfosCell.objects.create(

    cell2 = WcsCardInfosCell.objects.create(

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

    cell2 = WcsCardInfosCell.objects.create(

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

    cell = WcsCardInfosCell(page=page, placeholder='content', order=0)

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    WcsCardInfosCell.objects.create(

    cell2 = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell2 = WcsCardInfosCell.objects.create(

    cell3 = WcsCardInfosCell.objects.create(page=page, placeholder='content', order=2, slug='sluga')

    # another cell as the same slug, but not a WcsCardInfosCell

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell.objects.create(

    cell = WcsCardInfosCell(page=page, placeholder='content', order=0)

    cell1 = WcsCardInfosCell.objects.create(

    cell2 = WcsCardInfosCell.objects.create(

-