combo/tests/test_wcs.py

# -*- coding: utf-8 -*-

import pytest

import copy
import json
import re

from django.apps import apps
from django.conf import settings
from django.core.cache import cache
from django.urls import reverse
from django.db import connection
from django.test.client import RequestFactory
from django.test.utils import CaptureQueriesContext
from django.utils.six.moves.urllib import parse as urlparse

import mock

from combo.data.library import get_cell_classes
from combo.data.models import CellBase, LinkListCell, Page, ValidityInfo
from combo.apps.search.engines import engines
from combo.apps.wcs.models import (
    WcsFormCell, WcsCurrentFormsCell,
    WcsFormsOfCategoryCell, WcsCurrentDraftsCell, WcsCategoryCell,
    TrackingCodeInputCell, BackofficeSubmissionCell, WcsCareFormsCell)

from combo.apps.search.models import SearchCell
from combo.apps.search.utils import index_site, search_site
from django.contrib.auth.models import AnonymousUser

from combo.utils import NothingInCacheException

from .test_manager import login

pytestmark = pytest.mark.django_db


WCS_FORMDEFS_DATA = [
    {'slug': 'form-title', 'title': 'form title', 'url': '/form-title/', 'keywords': ['foo', 'bar']},
    {'slug': 'a-second-form-title', 'title': 'a second form title', 'url': '/a-second-form-title/'},
    {'slug': 'a-private-form', 'title': 'a private form', 'url': '/a-private-form/'},
    {'slug': 'third-form-title', 'title': 'third form title', 'url': '/third-form-title/'},
]

WCS_CATEGORIES_DATA = [
    {'slug': 'test-%s' % i, 'title': 'Test %s' % i, 'url': '/test-%s/' % i}
    for i in [3, 9]
]

WCS_CATEGORIES_FORMDEFS_DATA = [
    {'slug': 'form-title', 'title': 'form title', 'url': '/form-title/', 'keywords': ['foo', 'bar'], 'count': 42},
    {'slug': 'a-second-form-title', 'title': 'a second form title', 'url': '/a-second-form-title/', 'count': 35},
]

WCS_USER_FORMS_DATA = [
    {'name': 'name', 'title': 'Title', 'url': '/form/1/', 'form_receipt_datetime': '2015-01-01T00:00:00', 'readable': True,
     'category_slug': 'test-9'},
    {'name': 'name', 'url': '/form/2/', 'form_receipt_datetime': '2015-01-01T00:00:00', 'readable': True},
    {'name': 'name', 'title': 'Title', 'url': '/form/3/', 'form_receipt_datetime': '2015-01-01T00:00:00'},
    {'name': 'name', 'title': 'Title', 'url': '/form/4/', 'form_receipt_datetime': '2015-01-01T00:00:00', 'readable': True,
     'form_status_is_endpoint': True, 'category_slug': 'test-9'},
]

WCS_FORMS_DATA = [
    {
        'form_receipt_datetime': '2019-10-17T16:46:03',
        'form_url_backoffice': '/backoffice/management/foobar/1/',
    },
    {
        'form_receipt_datetime': '2019-10-17T16:46:04',
        'form_url_backoffice': '/backoffice/management/foobar/2/',
    },
]

WCS_USER_DRAFTS_DATA = [
    {'name': 'name', 'title': 'Title', 'url': '/form/1/', 'form_receipt_datetime': '2015-01-01T00:00:00', 'category_slug': 'test-9'},
    {'name': 'name', 'url': '/form/2/', 'form_receipt_datetime': '2015-01-01T00:00:00'},
    {'name': 'name', 'title': 'Title', 'url': '/form/3/', 'form_receipt_datetime': '2015-01-01T00:00:00'},
    {'name': 'name', 'title': 'Title', 'url': '/form/4/', 'form_receipt_datetime': '2015-01-01T00:00:00',
     'form_status_is_endpoint': True, 'category_slug': 'test-9'},
]


class MockUser(object):
    email = 'foo@example.net'
    is_authenticated = True

    def get_name_id(self):
        return None


class MockUserWithNameId(object):
    email = 'foo@example.net'
    is_authenticated = True

    def get_name_id(self):
        return 'xyz'


class MockedRequestResponse(mock.Mock):
    status_code = 200

    def json(self):
        return json.loads(self.content)


def get_data_from_url(url):
    if '/api/formdefs/' in url:
        return WCS_FORMDEFS_DATA
    if '/api/categories/' in url:
        if '/formdefs/' in url:
            return WCS_CATEGORIES_FORMDEFS_DATA
        return WCS_CATEGORIES_DATA
    if '/api/user/forms' in url:
        return WCS_USER_FORMS_DATA
    if '/api/forms' in url:
        return WCS_FORMS_DATA
    if '/api/user/drafts' in url:
        return WCS_USER_DRAFTS_DATA
    return []


def mocked_requests_send(request, **kwargs):
    request_url = urlparse.urlparse(request.url)
    data = copy.deepcopy(get_data_from_url(request_url.path))
    for elem in data:
        for key in ['url', 'form_url_backoffice']:
            if key not in elem:
                continue
            elem_url = elem[key]
            elem[key] = '{scheme}://{netloc}{url}'.format(scheme=request_url.scheme, netloc=request_url.netloc, url=elem_url)

    return MockedRequestResponse(content=json.dumps({'data': data}))


@pytest.fixture
def context():
    ctx = {'request': RequestFactory().get('/')}
    ctx['request'].user = None
    ctx['request'].session = {}
    return ctx


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_form_cell_setup(mock_send):
    cell = WcsFormCell()
    form_class = cell.get_default_form_class()
    form = form_class()
    assert form.fields['formdef_reference'].widget.choices == [
            (u'default:a-private-form', u'test : a private form'),
            (u'default:a-second-form-title', u'test : a second form title'),
            (u'default:form-title', u'test : form title'),
            (u'default:third-form-title', u'test : third form title'),
            (u'other:a-private-form', u'test2 : a private form'),
            (u'other:a-second-form-title', u'test2 : a second form title'),
            (u'other:form-title', u'test2 : form title'),
            (u'other:third-form-title', u'test2 : third form title')]


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_form_cell_save_cache(mock_send):
    page = Page(title='xxx', slug='test_form_cell_save_cache', template_name='standard')
    page.save()
    cell = WcsFormCell(page=page, placeholder='content', order=0)
    assert cell.get_additional_label() is None
    cell.formdef_reference = u'default:form-title'
    cell.save()
    assert cell.cached_title == 'form title'
    assert cell.get_additional_label() == 'form title'
    # make sure cached attributes are removed from serialized pages
    assert 'cached_' not in json.dumps(page.get_serialized_page())

    # check content provided to search engine
    assert cell.render_for_search() == ''
    assert cell.get_external_links_data() == [
        {'title': 'form title',
         'url': 'http://127.0.0.1:8999/form-title/',
         'text': 'foo bar'}]

    # artificially change title
    WcsFormCell.objects.filter(id=cell.id).update(cached_title='XXX')
    assert WcsFormCell.objects.get(id=cell.id).cached_title == 'XXX'
    # run update db cache
    appconfig = apps.get_app_config('wcs')
    appconfig.update_db_cache()
    assert WcsFormCell.objects.get(id=cell.id).cached_title == 'form title'


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


def test_form_cell_load():
    page = Page(title='xxx', slug='test_form_cell_save_cache', template_name='standard')
    page.save()
    cell = WcsFormCell(page=page, placeholder='content', order=0)
    cell.formdef_reference = u'default:form-title'
    cell.save()
    site_export = [page.get_serialized_page()]
    cell.delete()
    assert not Page.objects.get(id=page.id).get_cells()
    Page.load_serialized_pages(site_export)
    page = Page.objects.get(slug='test_form_cell_save_cache')
    cells = page.get_cells()
    assert len(cells) == 1
    cell = cells[0]
    assert cell.cached_title == 'form title'


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_category_cell_save_cache(mock_send):
    page = Page(title='xxx', slug='test_category_cell_save_cache', template_name='standard')
    page.save()
    cell = WcsCategoryCell(page=page, placeholder='content', order=0)
    assert cell.get_additional_label() is None
    cell.category_reference = u'default:test-3'
    cell.save()
    assert cell.cached_title == 'Test 3'
    assert cell.get_additional_label() == 'Test 3'


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.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_form_cell_render(mock_send):
    page = Page(title='xxx', slug='test_form_cell_render', template_name='standard')
    page.save()
    cell = WcsFormCell(page=page, placeholder='content', order=0)
    cell.formdef_reference = u'default:form-title'
    cell.save()
    result = cell.render({})
    assert 'http://127.0.0.1:8999/form-title/tryauth' in result
    assert 'form title' in result


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_current_forms_cell_setup(mock_send):
    cell = WcsCurrentFormsCell()
    form_class = cell.get_default_form_class()
    form = form_class()
    assert form.fields['wcs_site'].widget.choices == [
            ('', 'All'), (u'default', u'test'), (u'other', u'test2')]
    assert 'current_forms' in form.fields
    assert cell.get_additional_label() == 'All Sites - Current Forms'
    cell.wcs_site = 'default'
    assert cell.get_additional_label() == 'test - Current Forms'
    cell.wcs_site = None

    cell.current_forms = True
    cell.done_forms = True
    assert cell.get_additional_label() == 'All Sites - All Forms'

    cell.current_forms = False
    cell.done_forms = True
    assert cell.get_additional_label() == 'All Sites - Done Forms'


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_current_forms_cell_render(mock_send, context):
    page = Page(title='xxx', slug='test_current_forms_cell_render', template_name='standard')
    page.save()
    cell = WcsCurrentFormsCell(page=page, placeholder='content', order=0)
    cell.save()

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

    # query should fail as nothing is cached
    cache.clear()
    with pytest.raises(NothingInCacheException):
        result = cell.render(context)

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

    # default is to get current forms from all wcs sites
    result = cell.render(context)
    assert 'http://127.0.0.1:8999/form/1/' in result
    assert 'http://127.0.0.1:8999/form/2/' not in result  # no title
    assert 'http://127.0.0.1:8999/form/3/' not in result  # not readable
    assert 'http://127.0.0.1:8999/form/4/' not in result  # done
    assert 'http://127.0.0.2:8999/form/1/' in result
    assert 'http://127.0.0.2:8999/form/2/' not in result
    assert 'http://127.0.0.2:8999/form/3/' not in result
    assert 'http://127.0.0.2:8999/form/4/' not in result

    # done forms
    cell.current_forms = False
    cell.done_forms = True
    cell.include_drafts = False
    cell.save()
    result = cell.render(context)
    assert 'http://127.0.0.1:8999/form/1/' not in result  # wip
    assert 'http://127.0.0.1:8999/form/4/' in result  # done
    assert 'http://127.0.0.2:8999/form/1/' not in result  # wip
    assert 'http://127.0.0.2:8999/form/4/' in result  # done

    # limit to a category
    cell.categories = {'data': ['default:test-3']}
    extra_context = cell.get_cell_extra_context(context)
    assert len(extra_context['forms']) == 0
    cell.categories = {'data': ['default:test-9']}
    extra_context = cell.get_cell_extra_context(context)
    assert len(extra_context['forms']) == 1

    # check both category limit and all forms
    cell.current_forms = True
    cell.done_forms = True
    extra_context = cell.get_cell_extra_context(context)
    assert len(extra_context['forms']) == 2

    # check both category limit and no forms
    cell.current_forms = False
    cell.done_forms = False
    extra_context = cell.get_cell_extra_context(context)
    assert len(extra_context['forms']) == 0

    # check include drafts
    cell.include_drafts = False
    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_cell_extra_context(context)
    assert requests_get.call_args_list[0][0][0] == '/api/user/forms?limit=100&sort=desc'

    cell.include_drafts = True
    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_cell_extra_context(context)
    assert requests_get.call_args_list[0][0][0] == '/api/user/forms?limit=100&sort=desc&include-drafts=on'

    # check empty messages
    cell.categories = {'data': ['default:test-3']}
    cell.current_forms = True
    cell.done_forms = False
    cell.include_drafts = False
    result = cell.render(context)
    assert 'There are no current forms.' in result
    cell.done_forms = True
    result = cell.render(context)
    assert 'There are no forms.' in result
    cell.current_forms = False
    result = cell.render(context)
    assert 'There are no done forms' in result


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_current_forms_cell_validity(mock_send, 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


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_current_forms_cell_check_validity(mock_send, 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


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_current_forms_cell_render_single_site(mock_send, context):
    page = Page(title='xxx', slug='test_current_forms_cell_render', template_name='standard')
    page.save()
    cell = WcsCurrentFormsCell(page=page, placeholder='content', order=0)
    cell.wcs_site = 'default'
    cell.save()

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

    # query should fail as nothing is cached
    cache.clear()
    with pytest.raises(NothingInCacheException):
        result = cell.render(context)

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

    result = cell.render(context)
    assert 'http://127.0.0.1:8999/form/1/' in result
    assert 'http://127.0.0.2:8999/form/1/' not in result


def test_current_forms_unknown_name_id(context):
    page = Page(title='xxx', slug='test_current_forms_cell_render', template_name='standard')
    page.save()
    cell = WcsCurrentFormsCell(page=page, placeholder='content', order=0)
    cell.wcs_site = 'default'
    cell.save()

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

    # query should fail as nothing is cached
    cache.clear()
    with pytest.raises(NothingInCacheException):
        cell.render(context)

    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.render(context)
    assert requests_get.call_args_list[0][0][0] == '/api/users/xyz/forms?limit=100&sort=desc'


def test_care_forms_cell_setup():
    cell = WcsCareFormsCell()
    form_class = cell.get_default_form_class()
    form = form_class()
    assert form.fields['wcs_site'].widget.choices == [
            ('', 'All'), (u'default', u'test'), (u'other', u'test2')]
    assert cell.get_additional_label() == 'All Sites'
    cell.wcs_site = 'default'
    assert cell.get_additional_label() == 'test'


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_care_forms_cell_render(mock_send, context):
    page = Page(title='xxx', slug='test_care_forms_cell_render', template_name='standard')
    page.save()
    cell = WcsCareFormsCell(page=page, placeholder='content', order=0)
    cell.save()

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

    # query should fail as nothing is cached
    cache.clear()
    with pytest.raises(NothingInCacheException):
        result = cell.render(context)

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

    result = cell.render(context)

    assert 'http://127.0.0.1:8999/backoffice/management/foobar/1' in result
    assert 'http://127.0.0.1:8999/backoffice/management/foobar/2' in result
    assert '"http://127.0.0.1:8999/backoffice/management/"' in result
    assert 'http://127.0.0.2:8999/backoffice/management/foobar/1' in result
    assert 'http://127.0.0.2:8999/backoffice/management/foobar/2' in result
    assert '"http://127.0.0.2:8999/backoffice/management/"' in result

    data = cell.get_data(context)
    assert 'default' in data
    assert 'other' in data


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


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_care_forms_cell_render_single_site(mock_send, context):
    page = Page(title='xxx', slug='test_care_forms_cell_render', template_name='standard')
    page.save()
    cell = WcsCareFormsCell(page=page, placeholder='content', order=0)
    cell.wcs_site = 'default'
    cell.save()

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

    # query should fail as nothing is cached
    cache.clear()
    with pytest.raises(NothingInCacheException):
        result = cell.render(context)

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

    result = cell.render(context)
    assert '"http://127.0.0.1:8999/backoffice/management/"' in result
    assert '"http://127.0.0.2:8999/backoffice/management/"' not in result

    data = cell.get_data(context)
    assert 'default' in data
    assert 'other' not in data


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_forms_of_category_cell_setup(mock_send):
    cell = WcsFormsOfCategoryCell()
    form_class = cell.get_default_form_class()
    form = form_class()
    assert form.fields['category_reference'].widget.choices == [
            (u'default:test-3', u'test : Test 3'),
            (u'default:test-9', u'test : Test 9'),
            (u'other:test-3', u'test2 : Test 3'),
            (u'other:test-9', u'test2 : Test 9')]


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_forms_of_category_cell_render(mock_send, context):
    page = Page(title='xxx', slug='test_forms_of_category_cell_render', template_name='standard')
    page.save()
    cell = WcsFormsOfCategoryCell(page=page, placeholder='content', order=0)
    cell.category_reference = 'default:test-9'
    cell.ordering = 'alpha'
    cell.save()
    context['synchronous'] = True  # to get fresh content
    result = cell.render(context)
    assert 'form title' in result and 'a second form title' in result
    assert result.index('form title') > result.index('a second form title')
    assert 'http://127.0.0.1:8999/form-title/tryauth' in result
    assert 'http://127.0.0.1:8999/a-second-form-title/tryauth' in result
    assert 'keyword-foo' in result
    assert 'keyword-bar' in result

    cell.ordering = 'popularity'
    cell.save()
    result = cell.render(context)
    assert 'form title' in result and 'a second form title' in result
    assert result.index('form title') < result.index('a second form title')

    cell.ordering = 'manual'
    cell.save()
    result = cell.render(context)
    # by default all forms should be present, in alphabetical order
    assert result.index('form title') > result.index('a second form title')

    # set a manual order
    cell.manual_order = {'data': ['default:test-9:a-second-form-title',
                                  'default:test-9:form-title']}
    cell.save()
    result = cell.render(context)
    assert result.index('form title') > result.index('a second form title')

    # make sure all forms are displayed even if the manual order only specify
    # some.
    cell.manual_order = {'data': ['default:test-9:a-second-form-title']}
    cell.save()
    result = cell.render(context)
    assert result.index('form title') > result.index('a second form title')
    assert 'form title' in result and 'a second form title' in result

    # check content provided to search engine
    assert cell.render_for_search() == ''
    assert len(list(cell.get_external_links_data())) == 2

    # existing category, but empty
    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)
        result = cell.render(context)
        assert '<h2>' not in result
        context['combo_display_even_empty_categories'] = True
        result = cell.render(context)
        assert '<h2>' in result
        context.pop('combo_display_even_empty_categories')


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


def test_forms_of_category_cell_check_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)

    # valid category
    cell.category_reference = 'default:test-9'
    cell.save()
    cell.check_validity()
    assert ValidityInfo.objects.exists() is False

    # valid category but empty
    cell.category_reference = 'default:test-1'
    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


def test_current_drafts_cell_render_unlogged(context):
    page = Page(title='xxx', slug='test_current_drafts_cell_render', template_name='standard')
    page.save()
    cell = WcsCurrentDraftsCell(page=page, placeholder='content', order=0)
    cell.save()
    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
        result = cell.render(context)
    assert requests_get.call_args_list[0][0][0] == '/api/user/drafts'
    assert 'http://127.0.0.1:8999/third-form-title' not in result  # no form


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_current_drafts_cell_render_logged_in(mock_send, context):
    page = Page(title='xxx', slug='test_current_drafts_cell_render', template_name='standard')
    page.save()
    cell = WcsCurrentDraftsCell(page=page, placeholder='content', order=0)
    cell.save()
    context['synchronous'] = True  # to get fresh content

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

    # default is to get current forms from all wcs sites
    result = cell.render(context)
    assert 'http://127.0.0.1:8999/form/1/' in result
    assert 'http://127.0.0.1:8999/form/2/' not in result  # no title
    assert 'http://127.0.0.1:8999/form/3/' in result
    assert 'http://127.0.0.1:8999/form/4/' not in result  # done
    assert 'http://127.0.0.2:8999/form/1/' in result
    assert 'http://127.0.0.2:8999/form/2/' not in result
    assert 'http://127.0.0.2:8999/form/3/' in result
    assert 'http://127.0.0.2:8999/form/4/' not in result

    # check flat list
    extra_context = cell.get_cell_extra_context(context)
    assert len(extra_context['drafts']) == 8
    assert len([x for x in extra_context['drafts'] if x['site_slug'] == 'default']) == 4
    assert len([x for x in extra_context['drafts'] if x['site_slug'] == 'other']) == 4

    # limit to a category
    cell.categories = {'data': ['default:test-3']}
    extra_context = cell.get_cell_extra_context(context)
    assert len(extra_context['drafts']) == 0
    cell.categories = {'data': ['default:test-9']}
    extra_context = cell.get_cell_extra_context(context)
    assert len(extra_context['drafts']) == 2

    # check empty message
    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
        result = cell.render(context)
    assert 'There are no current drafts.' in result

    context['request'].user = MockUserWithNameId()
    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 requests_get.call_args_list[0][0][0] == '/api/users/xyz/drafts'


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_current_drafts_cell_check_validity(mock_send, 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


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_manager_forms_of_category_cell(mock_send, app, admin_user):
    page = Page(title='One', slug='one', template_name='standard')
    page.save()
    app = login(app)
    resp = app.get('/manage/pages/%s/' % page.id)
    resp = app.get(resp.html.find('option',
                   **{'data-add-url': re.compile('wcsformsofcategorycell')})['data-add-url'])

    cells = Page.objects.get(id=page.id).get_cells()
    assert len(cells) == 1
    assert isinstance(cells[0], WcsFormsOfCategoryCell)

    resp = app.get('/manage/pages/%s/' % page.id)
    assert ('data-cell-reference="%s"' % cells[0].get_reference()) in resp.text
    resp.forms[0]['c%s-ordering' % cells[0].get_reference()].value = 'manual'
    resp = resp.forms[0].submit()
    assert resp.status_int == 302


def test_manager_current_forms(app, admin_user):
    page = Page(title='One', slug='one', template_name='standard')
    page.save()
    app = login(app)
    resp = app.get('/manage/pages/%s/' % page.id)
    resp = app.get(resp.html.find('option',
                   **{'data-add-url': re.compile('wcscurrentformscell')})['data-add-url'])

    cells = Page.objects.get(id=page.id).get_cells()
    assert len(cells) == 1
    assert isinstance(cells[0], WcsCurrentFormsCell)

    resp = app.get('/manage/pages/%s/' % page.id)
    assert ('data-cell-reference="%s"' % cells[0].get_reference()) in resp.text
    assert len(resp.form['c%s-categories' % cells[0].get_reference()].options) == 4
    resp.form['c%s-categories' % cells[0].get_reference()].value = ['default:test-3', 'default:test-9']
    resp = resp.form.submit().follow()
    assert resp.form['c%s-categories' % cells[0].get_reference()].value == ['default:test-3', 'default:test-9']

    # check wcs_site field is a select box
    assert resp.form['c%s-wcs_site' % cells[0].get_reference()].tag == 'select'

    try:
        # check the wcs_site field is hidden if there's a single one defined in
        # the configuration
        temp_settings = settings.KNOWN_SERVICES.copy()
        default = settings.KNOWN_SERVICES['wcs']['default']
        settings.KNOWN_SERVICES = {'wcs': {'default': default}}
        resp = app.get('/manage/pages/%s/' % page.id)
        assert resp.form['c%s-wcs_site' % cells[0].get_reference()].attrs['type'] == 'hidden'
    finally:
        # restore original settings
        settings.KNOWN_SERVICES = temp_settings


def test_tracking_code_cell(app, nocache):
    page = Page(title='One', slug='index', template_name='standard')
    page.save()
    cell = TrackingCodeInputCell(page=page, placeholder='content', order=0)
    cell.save()

    resp = app.get('/')
    resp.form['code'] = 'FOOBAR'
    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
        resp = resp.form.submit()
    assert len(requests_get.call_args_list) == 2
    assert requests_get.call_args_list[0][0][0] == '/api/code/FOOBAR'
    assert requests_get.call_args_list[1][0][0] == '/api/code/FOOBAR'
    remote_service_urls = [c[1]['remote_service']['url'] for c in requests_get.call_args_list]
    assert set(remote_service_urls) == set(['http://127.0.0.1:8999/', 'http://127.0.0.2:8999/'])
    assert resp.status_code == 302
    resp = resp.follow()
    assert '<li class="error">The tracking code could not been found.</li>' in resp.text

    resp = app.get('/')
    resp.form['code'] = 'FOO?BAR?bad<code>'
    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
        resp = resp.form.submit()
    assert requests_get.call_args_list[0][0][0] == '/api/code/FOO%3FBAR%3FBAD%3CCODE%3E'
    assert resp.status_code == 302
    resp = resp.follow()
    assert '<li class="error">The tracking code could not been found.</li>' in resp.text

    resp = app.get('/')
    resp.form['code'] = 'CNPHNTFB'
    with mock.patch('combo.apps.wcs.models.requests.get') as requests_get:
        requests_get.return_value = MockedRequestResponse(content=json.dumps({'err': 0, 'load_url': 'http://127.0.0.2:8999/code/CNPHNTFB/load'}))
        resp = resp.form.submit()
    assert resp.status_code == 302
    assert resp.location == 'http://127.0.0.2:8999/code/CNPHNTFB/load'

    # space/case
    resp = app.get('/')
    resp.form['code'] = ' cnphntfb'
    with mock.patch('combo.apps.wcs.models.requests.get') as requests_get:
        requests_get.side_effect = [
            mock.Mock(status_code=200),
            MockedRequestResponse(content=json.dumps({'err': 0, 'load_url': 'http://127.0.0.2:8999/code/CNPHNTFB/load'}))
        ]
        resp = resp.form.submit()
    assert requests_get.call_args_list[0][0][0] == '/api/code/CNPHNTFB'
    assert requests_get.call_args_list[1][0][0] == '/api/code/CNPHNTFB'
    assert resp.status_code == 302
    assert resp.location == 'http://127.0.0.2:8999/code/CNPHNTFB/load'

    # lock cell to a single site
    cell.wcs_site = 'default'
    cell.save()
    resp = app.get('/')
    resp.form['code'] = 'CNPHNTFB'
    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
        resp = resp.form.submit()
    assert len(requests_get.call_args_list) == 1
    assert requests_get.call_args_list[0][1]['remote_service']['url'] == 'http://127.0.0.1:8999/'
    resp = resp.follow()
    assert '<li class="error">The tracking code could not been found.</li>' in resp.text

    # simulate cell being displayed on a different site
    resp = app.get('/')
    resp.form['url'] = 'http://example.org/'
    resp.form['code'] = 'CNPHNTFB'
    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
        resp = resp.form.submit()
    assert resp.location == 'http://example.org/?unknown-tracking-code'

    resp = app.get('/')
    resp.form['url'] = 'http://example.org/?foo=bar'
    resp.form['code'] = 'CNPHNTFB'
    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
        resp = resp.form.submit()
    assert resp.location == 'http://example.org/?foo=bar&unknown-tracking-code'

    # redirect to an unknown site
    resp = app.get('/')
    resp.form['url'] = 'http://example.net/'
    resp.form['code'] = 'CNPHNTFB'
    resp = resp.form.submit(status=400)

    # error handling
    resp = app.get('/')
    resp.form['cell'] = '9999'
    resp.form['code'] = 'CNPHNTFB'
    resp = resp.form.submit(status=400)

    resp = app.get('/')
    resp.form['cell'] = 'xxxx'
    resp.form['code'] = 'CNPHNTFB'
    resp = resp.form.submit(status=400)

    resp = app.post(reverse('wcs-tracking-code'), params={'cell': cell.id}, status=400)


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_cell_assets(mock_send, settings, app, admin_user):
    page = Page.objects.create(title='xxx', slug='test_cell_assets', template_name='standard')
    cell1 = WcsFormCell.objects.create(page=page, placeholder='content', order=0, formdef_reference=u'default:form-title')

    cell2 = WcsFormsOfCategoryCell.objects.create(
        page=page, placeholder='content', order=0,
        category_reference='default:test-9',
        ordering='alpha')

    app = login(app)
    settings.WCS_CATEGORY_ASSET_SLOTS = {}
    settings.WCS_FORM_ASSET_SLOTS = {}
    settings.COMBO_CELL_ASSET_SLOTS = {}
    resp = app.get('/manage/assets/')
    assert 'have any asset yet.' in resp.text

    # Old settings have priority
    settings.WCS_CATEGORY_ASSET_SLOTS = {'logo': {'prefix': 'Logo'}}
    settings.WCS_FORM_ASSET_SLOTS = {'picture': {'prefix': 'Picture'}}
    settings.COMBO_CELL_ASSET_SLOTS = {
        'wcs_wcsformcell': {'picture': {'prefix': 'Picture blabla', 'suffix': 'test'}},
        'wcs_wcsformsofcategorycell': {'logo': {'prefix': 'Logo blabla', 'suffix': 'test'}},
    }
    resp = app.get('/manage/assets/')
    assert u'>Logo — %s<' % cell2.get_label_for_asset() in resp.text
    assert u'>Logo blabla — %s<' % cell2.get_label_for_asset() not in resp.text
    assert u'>Picture — %s<' % cell1.get_label_for_asset() in resp.text
    assert u'>Picture blabla — %s<' % cell1.get_label_for_asset() not in resp.text
    # New settings
    settings.WCS_CATEGORY_ASSET_SLOTS = {}
    settings.WCS_FORM_ASSET_SLOTS = {}
    settings.COMBO_CELL_ASSET_SLOTS = {
        'wcs_wcsformcell': {'picture': {'prefix': 'Picture'}},
        'wcs_wcsformsofcategorycell': {'logo': {'prefix': 'Logo'}},
    }
    resp = app.get('/manage/assets/')
    assert u'>Logo — %s<' % cell2.get_label_for_asset() in resp.text
    assert u'>Picture — %s<' % cell1.get_label_for_asset() in resp.text

    # test suffix
    settings.COMBO_CELL_ASSET_SLOTS = {
        'wcs_wcsformcell': {'picture': {'prefix': 'Picture', 'suffix': 'test'}},
        'wcs_wcsformsofcategorycell': {'logo': {'prefix': 'Logo', 'suffix': 'test'}},
    }
    resp = app.get('/manage/assets/')
    assert u'>Logo — %s (test)<' % cell2.get_label_for_asset() in resp.text
    assert u'>Picture — %s (test)<' % cell1.get_label_for_asset() in resp.text


def test_tracking_code_search(settings, app, nocache):
    settings.TEMPLATE_VARS['is_portal_agent'] = True

    with mock.patch('combo.apps.wcs.models.requests.get') as requests_get:
        result = app.get('/api/search/tracking-code/').json
        assert len(result.get('data')) == 0
        assert result.get('err') == 0
    assert requests_get.called is False  # no code

    with mock.patch('combo.apps.wcs.models.requests.get') as requests_get:
        assert len(app.get('/api/search/tracking-code/?q=123').json.get('data')) == 0
    assert requests_get.called is False  # no letters

    with mock.patch('combo.apps.wcs.models.requests.get') as requests_get:
        assert len(app.get('/api/search/tracking-code/?q=BBCCDFF').json.get('data')) == 0
    assert requests_get.called is False  # too short

    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
        assert len(app.get('/api/search/tracking-code/?q=BBCCDDFF').json.get('data')) == 0
    assert len(requests_get.call_args_list) == 2
    assert requests_get.call_args_list[0][0][0] == '/api/code/BBCCDDFF'
    assert requests_get.call_args_list[1][0][0] == '/api/code/BBCCDDFF'
    remote_service_urls = [c[1]['remote_service']['url'] for c in requests_get.call_args_list]
    assert set(remote_service_urls) == set(['http://127.0.0.1:8999/', 'http://127.0.0.2:8999/'])

    with mock.patch('combo.apps.wcs.models.requests.get') as requests_get:
        requests_get.return_value = MockedRequestResponse(content=json.dumps({'err': 0, 'load_url': 'http://127.0.0.2:8999/code/CNPHNTFB/load'}))
        assert len(app.get('/api/search/tracking-code/?q=CNPHNTFB').json.get('data')) == 1
    assert requests_get.call_args_list[0][0][0] == '/api/code/CNPHNTFB'

    with mock.patch('combo.apps.wcs.models.requests.get') as requests_get:
        assert len(app.get('/api/search/tracking-code/?q=BBCCDDFFG').json.get('data')) == 0
    assert requests_get.called is False  # too long

    with mock.patch('combo.apps.wcs.models.requests.get') as requests_get:
        requests_get.side_effect = [
            mock.Mock(status_code=200),
            MockedRequestResponse(content=json.dumps({'err': 0, 'load_url': 'http://127.0.0.2:8999/code/CNPHNTFB/load'}))
        ]
        assert len(app.get('/api/search/tracking-code/?q= cnphntfb').json.get('data')) == 1
    assert requests_get.call_args_list[0][0][0] == '/api/code/CNPHNTFB'


def test_tracking_code_search_rate_limit(settings, app):
    settings.TEMPLATE_VARS['is_portal_agent'] = True
    settings.WCS_TRACKING_CODE_RATE_LIMIT = '0/s'
    assert app.get('/api/search/tracking-code/?q=BBCCDDFF').json.get('err') == 1

    page = Page(title='One', slug='index', template_name='standard')
    page.save()
    cell = TrackingCodeInputCell(page=page, placeholder='content', order=0)
    cell.save()

    resp = app.get('/')
    resp.form['code'] = 'FOOBAR'
    resp = resp.form.submit()
    assert resp.status_code == 302
    resp = resp.follow()
    assert '<li class="error">Looking up tracking code is currently rate limited.</li>' in resp.text

    resp = app.get('/')
    resp.form['code'] = 'FOOBAR'
    resp.form['url'] = 'http://example.org/'
    resp = resp.form.submit(status=403)


def test_wcs_search_engines(app):
    settings.TEMPLATE_VARS['is_portal_agent'] = True
    search_engines = engines.get_engines()
    assert 'tracking-code' in search_engines.keys()
    assert len([x for x in search_engines.keys() if x.startswith('formdata:')]) == 2
    settings.TEMPLATE_VARS['is_portal_agent'] = False
    search_engines = engines.get_engines()
    assert 'tracking-code' not in search_engines.keys()
    assert len([x for x in search_engines.keys() if x.startswith('formdata:')]) == 0


def test_backoffice_submission_cell_render(context):
    page = Page(title='xxx', slug='test_backoffice_submission_cell_render', template_name='standard')
    page.save()
    cell = BackofficeSubmissionCell(page=page, placeholder='content', order=0)
    cell.wcs_site = 'default'
    cell.save()

    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
        result = cell.render(context)
    assert requests_get.call_args_list[0][0][0] == '/api/formdefs/?backoffice-submission=on'
    assert context['all_formdefs'] == {}
    assert 'h2' not in result

    with mock.patch('combo.apps.wcs.models.requests.get') as requests_get:
        requests_get.return_value = MockedRequestResponse(content=json.dumps(
            {'data': [{'backoffice_submission_url': '/backoffice/submission/a-private-form/', 'title': 'Foo'}]}))
        result = cell.render(context)
    assert '/backoffice/submission/a-private-form/' in result
    assert list(context['all_formdefs'].keys()) == ['default']
    assert 'h2' in result


def test_manager_link_list_cell_duplicate():
    page = Page.objects.create(title='xxx', slug='new', template_name='standard')
    cell = LinkListCell.objects.create(order=0, page=page)
    item = WcsFormCell.objects.create(
        page=page,
        placeholder=cell.link_placeholder,
        cached_title='A title',
        cached_url='http://example.com',
        cached_json={'foo': 'bar'},
        order=1)

    new_cell = cell.duplicate()
    assert WcsFormCell.objects.count() == 2
    assert len(new_cell.get_items()) == 1
    new_item = new_cell.get_items()[0]
    assert new_item.page == page
    assert new_item.placeholder == new_cell.link_placeholder
    assert new_item.pk != item.pk
    assert new_item.cached_title == item.cached_title
    assert new_item.cached_url == item.cached_url
    assert new_item.cached_json == item.cached_json


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_manager_add_edit_delete_list_link_item(mock_send, app, admin_user):
    page = Page.objects.create(title='One', slug='one', template_name='standard')
    cell = LinkListCell.objects.create(order=0, placeholder='content', page=page)
    app = login(app)
    resp = app.get('/manage/pages/%s/' % page.pk)

    resp = resp.click(href='.*/add-link/form-link$')
    resp.forms[0]['formdef_reference'] = 'default:form-title'
    resp = resp.forms[0].submit()
    assert resp.status_int == 302
    assert resp.location.endswith('/manage/pages/%s/#cell-%s' % (page.pk, cell.get_reference()))
    assert WcsFormCell.objects.count() == 1
    item = WcsFormCell.objects.get()
    assert item.formdef_reference == 'default:form-title'
    assert item.page == page
    assert item.placeholder == cell.link_placeholder

    resp = resp.follow()
    resp = resp.click(href='.*/link/%s/$' % item.get_reference())
    resp.forms[0]['formdef_reference'] = 'default:a-private-form'
    resp = resp.forms[0].submit()
    assert resp.status_int == 302
    assert resp.location.endswith('/manage/pages/%s/#cell-%s' % (page.pk, cell.get_reference()))
    assert WcsFormCell.objects.count() == 1
    item.refresh_from_db()
    assert item.formdef_reference == 'default:a-private-form'

    resp = resp.follow()
    resp = resp.click(href='.*/link/%s/delete' % item.get_reference())
    resp = resp.forms[0].submit()
    assert resp.status_int == 302
    assert resp.location.endswith('/manage/pages/%s/#cell-%s' % (page.pk, cell.get_reference()))
    assert WcsFormCell.objects.count() == 0


def test_import_export_pages_with_links():
    page = Page(title=u'bar', slug='bar', order=1)
    page.save()

    cell = LinkListCell.objects.create(order=0, placeholder='content', page=page)
    item = WcsFormCell.objects.create(
        page=page,
        placeholder=cell.link_placeholder,
        cached_title='A title',
        cached_url='http://example.com',
        cached_json={'foo': 'bar'},
        order=0,
    )

    site_export = [x.get_serialized_page() for x in Page.objects.all()]

    Page.load_serialized_pages(site_export)

    new_page = Page.objects.get()
    new_cells = CellBase.get_cells(page_id=new_page.id, placeholder='content')
    assert len(new_cells[0].get_items()) == 1
    new_item = new_cells[0].get_items()[0]
    assert isinstance(new_item, WcsFormCell)
    assert new_item.cached_title == item.cached_title
    assert new_item.cached_url == item.cached_url
    assert new_item.cached_json == item.cached_json


def test_list_of_links_with_form_render(app):
    page = Page(title='xxx', slug='test_list_of_links_with_form_render', template_name='standard')
    page.save()

    cell = LinkListCell.objects.create(order=0, placeholder='content', page=page)
    WcsFormCell.objects.create(
        page=page,
        placeholder=cell.link_placeholder,
        cached_title='A title',
        cached_url='http://example.com',
        cached_json={'keywords': ['bar']},
        order=0,
    )

    resp = app.get('/test_list_of_links_with_form_render/')
    assert 'A title' in resp
    assert 'keyword-bar' in resp


def test_view_page_with_wcs_cells_num_queries(app, admin_user):
    page = Page.objects.create(title=u'bar', slug='index', order=1)
    for i in range(0, 15):
        WcsCurrentDraftsCell.objects.create(
            page=page,
            placeholder='content',
            order=i)
    for i in range(15, 50):
        WcsCurrentFormsCell.objects.create(
            page=page,
            placeholder='content',
            order=i)
    app = login(app)
    app.get('/')  # load once to populate caches
    with CaptureQueriesContext(connection) as ctx:
        app.get('/')
        assert len(ctx.captured_queries) == 61


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, WcsFormsOfCategoryCell]:
            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


@mock.patch('combo.apps.wcs.utils.requests.send', side_effect=mocked_requests_send)
def test_search_external_forms_links(mock_send, context):
    page = Page(title='xxx', slug='test_forms_of_category_cell_search',
                template_name='standard')
    page.save()

    cell = SearchCell(page=page, _search_services={'data': ['_text']}, order=0)
    cell.save()

    index_site()
    request = RequestFactory().get('/')
    request.user = AnonymousUser()
    hits = search_site(request, 'form')
    assert len(hits) == 0

    cell = WcsFormsOfCategoryCell(page=page, placeholder='content', order=1)
    cell.category_reference = 'default:test-9'
    cell.ordering = 'alpha'
    cell.save()
    context['synchronous'] = True  # to get fresh content
    result = cell.render(context)
    assert 'form title' in result and 'a second form title' in result
    assert 'http://127.0.0.1:8999/form-title/tryauth' in result
    assert 'http://127.0.0.1:8999/a-second-form-title/tryauth' in result

    index_site()
    request = RequestFactory().get('/')
    request.user = AnonymousUser()
    hits = search_site(request, 'form')
    assert len(hits) == 2