combo/tests/test_wcs.py

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

import pytest

import json
import re
import requests
import subprocess
import shutil
import sys
import tempfile
import time
import os

from django.apps import apps
from django.conf import settings
from django.core.cache import cache
from django.core.urlresolvers import reverse
from django.test import override_settings
from django.test.client import RequestFactory
from django.utils.six.moves.urllib import parse as urlparse

import mock

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

from combo.utils import NothingInCacheException

from .test_manager import login

pytestmark = pytest.mark.django_db

wcs_present = pytest.mark.skipif('WCS_MANAGE' not in os.environ or not os.path.exists(os.environ['WCS_MANAGE']),
        reason='WCS_MANAGE not defined in environment')

WCS_MANAGE = os.environ.get('WCS_MANAGE')

WCS_SCRIPTS = {
        'setup-auth': """
from quixote import get_publisher

get_publisher().cfg['identification'] = {'methods': ['password']}
get_publisher().cfg['debug'] = {'display_exceptions': 'text'}
get_publisher().write_cfg()
""",
        'create-user': """
from quixote import get_publisher
from qommon.ident.password_accounts import PasswordAccount

user = get_publisher().user_class()
user.name = 'foo bar'
user.email = 'foo@example.net'
user.store()
account = PasswordAccount(id='user')
account.set_password('user')
account.user_id = user.id
account.store()
""",
        'create-data': """
import datetime
from quixote import get_publisher

from wcs.categories import Category
from wcs.formdef import FormDef
from wcs.roles import Role
from wcs import fields

cats = []
for i in range(1, 10):
   cat = Category()
   cat.name = 'Test %d' % i
   cat.description = 'Hello world'
   cat.store()
   cats.append(cat)

formdef = FormDef()
formdef.name = 'form title'
formdef.category_id = cat.id
formdef.fields = [
    fields.StringField(id='1', label='1st field', type='string'),
    fields.ItemField(id='2', label='2nd field', type='item',
                     items=['foo', 'bar', 'baz']),
]
formdef.store()

user = get_publisher().user_class.select()[0]

for i in range(50):
    formdata = formdef.data_class()()
    formdata.just_created()
    formdata.receipt_time = datetime.datetime(2015, 1, 1).timetuple()
    formdata.data = {'1': 'FOO BAR %d' % i}
    if i%4 == 0:
        formdata.data['2'] = 'foo'
        formdata.data['2_display'] = 'foo'
    elif i%4 == 1:
        formdata.data['2'] = 'bar'
        formdata.data['2_display'] = 'bar'
    else:
        formdata.data['2'] = 'baz'
        formdata.data['2_display'] = 'baz'
    if i%3 == 0:
        formdata.jump_status('new')
    else:
        formdata.jump_status('finished')
    if i%7 == 0:
        formdata.user_id = user.id
    formdata.store()

# another formdef in same category
formdef = FormDef()
formdef.name = 'a second form title'
formdef.category_id = cat.id
formdef.fields = []
formdef.store()

# a formdef in another category
formdef = FormDef()
formdef.name = 'third form title'
formdef.category_id = cats[2].id
formdef.fields = []
formdef.enable_tracking_codes = True
formdef.store()

# a draft of that formdef
formdata = formdef.data_class()()
formdata.data = {}
formdata.page_no = 1
formdata.status = 'draft'
formdata.receipt_time = datetime.datetime(2015, 1, 1).timetuple()
formdata.user_id = user.id
formdata.store()

if '127.0.0.2' in get_publisher().get_frontoffice_url():
    # create a tracking code on second website only
    code = get_publisher().tracking_code_class()
    code.id = 'CNPHNTFB'
    code.formdata = formdata

# a private formdef
role = Role(name='Blah')
role.store()

formdef = FormDef()
formdef.name = 'a private form'
formdef.category_id = cats[2].id
formdef.roles = [role.id]
formdef.backoffice_submission_roles = [role.id]
formdef.fields = []
formdef.store()

user2 = get_publisher().user_class()  # agent
user2.name = 'foo2 bar2'
user2.email = 'foo2@example.net'
user2.roles = [role.id]
user2.store()
""",

}

WCS_DIR = tempfile.mkdtemp()
WCS_PID = None


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'


def run_wcs_script(script, hostname):
    script_path = os.path.join(WCS_DIR, script + '.py')
    fd = open(script_path, 'w')
    fd.write(WCS_SCRIPTS[script])
    fd.close()
    subprocess.check_call([sys.executable, WCS_MANAGE, 'runscript', '--app-dir', WCS_DIR,
        '--vhost', hostname, script_path],
        env={'DJANGO_SETTINGS_MODULE': 'wcs.settings'})


def setup_module(module):
    global WCS_PID

    if not WCS_MANAGE:
        return

    for hostname in ['127.0.0.1', '127.0.0.2']:
        os.mkdir(os.path.join(WCS_DIR, hostname))

        run_wcs_script('setup-auth', hostname)
        run_wcs_script('create-user', hostname)
        run_wcs_script('create-data', hostname)

        fd = file(os.path.join(WCS_DIR, hostname, 'site-options.cfg'), 'w')
        fd.write('''[api-secrets]
combo = combo
''')
        fd.close()

    with open(os.path.join(WCS_DIR, 'wcs.cfg'), 'w') as fd:
        fd.write('''[main]
app_dir = %s\n''' % WCS_DIR)

    with open(os.path.join(WCS_DIR, 'local_settings.py'), 'w') as fd:
        fd.write('''
WCS_LEGACY_CONFIG_FILE = '%s/wcs.cfg'
THEMES_DIRECTORY = '/'
ALLOWED_HOSTS = ['127.0.0.1', '127.0.0.2']
''' % WCS_DIR)

    WCS_PID = os.fork()
    if not WCS_PID:
        os.chdir(os.path.dirname(WCS_MANAGE))
        os.environ['DJANGO_SETTINGS_MODULE'] = 'wcs.settings'
        os.environ['WCS_SETTINGS_FILE'] = os.path.join(WCS_DIR, 'local_settings.py')
        os.execvp('python', [sys.executable, 'manage.py', 'runserver', '--noreload', '0.0.0.0:8999'])
        sys.exit(0)

    time.sleep(5)

def teardown_module(module):
    if WCS_PID:
        os.kill(WCS_PID, 9)
        shutil.rmtree(WCS_DIR)


def check_wcs_open(url):
    session = requests.Session()
    scheme, netloc, path, query, fragment = urlparse.urlsplit(url)
    path = '/login/'
    login_url = urlparse.urlunsplit((scheme, netloc, path, query, fragment))
    resp = session.post(login_url, data={'username': 'user', 'password': 'user'})
    resp = session.get(url)
    assert resp.status_code == 200


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

@wcs_present
def test_form_cell_setup():
    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')]


@wcs_present
def test_form_cell_save_cache():
    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 not 'cached_' 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': ''}]

    # 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'

@wcs_present
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'


@wcs_present
def test_category_cell_save_cache():
    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'

@wcs_present
def test_form_cell_render():
    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

@wcs_present
def test_current_forms_cell_setup():
    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'

@wcs_present
def test_current_forms_cell_render(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-title/1/' in result
    assert 'http://127.0.0.1:8999/form-title/22/' in result
    assert not 'http://127.0.0.1:8999/form-title/8/' in result
    assert 'http://127.0.0.2:8999/form-title/1/' in result
    assert 'http://127.0.0.2:8999/form-title/22/' in result

    # done forms
    cell.current_forms = False
    cell.done_forms = True
    cell.save()
    result = cell.render(context)
    assert not 'http://127.0.0.1:8999/form-title/1/' in result
    assert 'http://127.0.0.1:8999/form-title/8/' in result

    data = cell.get_data(context)
    assert data['default']['data'][0]['site_slug'] == 'default'
    assert data['other']['data'][0]['site_slug'] == 'other'

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

    # 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']) == 5

    # 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']) == 8

    # 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

@wcs_present
def test_current_forms_cell_render_single_site(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-title/1/' in result
    assert 'http://127.0.0.1:8999/form-title/22/' in result
    assert 'http://127.0.0.2:8999/form-title/1/' not in result
    assert 'http://127.0.0.2:8999/form-title/22/' not in result

@wcs_present
def test_current_forms_unknown_name_id(caplog, 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):
        result = cell.render(context)

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

    result = cell.render(context)
    assert 'http://127.0.0.1:8999/' not in result
    assert len(caplog.records) == 0


@wcs_present
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'


@wcs_present
def test_care_forms_cell_render(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

    with mock.patch('combo.apps.wcs.models.requests.get') as requests_get:
        response1 = {'err': 0, 'data': [
            {
                'form_receipt_datetime': '2019-10-17T16:46:03',
                'form_url_backoffice': 'http://127.0.0.1:8999/backoffice/management/foobar/1/',
            },
            {
                'form_receipt_datetime': '2019-10-17T16:46:04',
                'form_url_backoffice': 'http://127.0.0.1:8999/backoffice/management/foobar/2/',
            },
        ]}
        response2 = {'err': 0, 'data': [
            {
                'form_receipt_datetime': '2019-10-17T16:46:05',
                'form_url_backoffice': 'http://127.0.0.2:8999/backoffice/management/foobar/42/',
            },
        ]}
        mock_json = mock.Mock(status_code=200)
        mock_json.json.side_effect = [response1, response2]
        requests_get.return_value = mock_json

        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/42' 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


@wcs_present
def test_care_forms_cell_render_single_site(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


@wcs_present
def test_forms_of_category_cell_setup():
    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')]

@wcs_present
def test_forms_of_category_cell_render(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

    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

@wcs_present
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
    result = cell.render(context)
    assert not 'http://127.0.0.1:8999/third-form-title' in result # no form

@wcs_present
def test_current_drafts_cell_render_logged_in(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/third-form-title/1' in result
    for url in re.findall(r'href=[\'"]?([^\'" >]+)', result):
        check_wcs_open(url)

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

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


@wcs_present
def test_manager_forms_of_category_cell(app, admin_user):
    Page.objects.all().delete()
    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

@wcs_present
def test_manager_current_forms(app, admin_user):
    Page.objects.all().delete()
    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


@wcs_present
def test_tracking_code_cell(app, nocache):
    Page.objects.all().delete()
    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">The tracking code could not been found.</li>' in resp.text

    resp = app.get('/')
    resp.form['code'] = 'FOO?BAR?bad<code>'
    resp = resp.form.submit()
    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'
    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'
    resp = resp.form.submit()
    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'
    resp = resp.form.submit()
    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'
    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'
    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)

@wcs_present
def test_cell_assets(app, admin_user):
    page = Page(title='xxx', slug='test_cell_assets', template_name='standard')
    page.save()
    cell = WcsFormCell(page=page, placeholder='content', order=0)
    cell.formdef_reference = u'default:form-title'
    cell.save()

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

    app = login(app)
    with override_settings(WCS_CATEGORY_ASSET_SLOTS={}):
        resp = app.get('/manage/assets/')
        assert 'have any asset yet.' in resp.text

    with override_settings(
            WCS_CATEGORY_ASSET_SLOTS={'logo': {'prefix': 'Logo'}},
            WCS_FORM_ASSET_SLOTS={'picture': {'prefix': 'Picture'}}):
        resp = app.get('/manage/assets/')
        assert u'>Logo — Test 9<' in resp.text
        assert u'>Picture — form title<' in resp.text

    with override_settings(
            WCS_CATEGORY_ASSET_SLOTS={'logo': {'prefix': 'Logo', 'suffix': 'test'}},
            WCS_FORM_ASSET_SLOTS={'picture': {'prefix': 'Picture', 'suffix': 'test'}}):
        resp = app.get('/manage/assets/')
        assert u'>Logo — Test 9 (test)<' in resp.text
        assert u'>Picture — form title (test)<' in resp.text

@wcs_present
def test_tracking_code_search(app, nocache):
    assert len(app.get('/api/search/tracking-code/').json.get('data')) == 0
    assert app.get('/api/search/tracking-code/').json.get('err') == 0
    assert len(app.get('/api/search/tracking-code/?q=123').json.get('data')) == 0
    assert len(app.get('/api/search/tracking-code/?q=BBCCDFF').json.get('data')) == 0
    assert len(app.get('/api/search/tracking-code/?q=BBCCDDFF').json.get('data')) == 0
    assert len(app.get('/api/search/tracking-code/?q=CNPHNTFB').json.get('data')) == 1
    assert len(app.get('/api/search/tracking-code/?q=BBCCDDFFG').json.get('data')) == 0
    assert len(app.get('/api/search/tracking-code/?q= cnphntfb').json.get('data')) == 1

@wcs_present
def test_tracking_code_search_rate_limit(app):
    for i in range(3):
        assert app.get('/api/search/tracking-code/?q=BBCCDDFF').json.get('err') == 0
    assert app.get('/api/search/tracking-code/?q=BBCCDDFF').json.get('err') == 1

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

    resp = app.get('/')
    for i in range(3): # make sure we hit ratelimit
        app.get('/api/search/tracking-code/?q=BBCCDDFF')
    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('/')
    for i in range(3): # make sure we hit ratelimit
        app.get('/api/search/tracking-code/?q=BBCCDDFF')
    resp.form['code'] = 'FOOBAR'
    resp.form['url'] = 'http://example.org/'
    resp = resp.form.submit(status=403)


@wcs_present
def test_wcs_search_engines(app):
    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

@wcs_present
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

    result = cell.render(context)
    assert '/backoffice/submission/a-private-form/' not in result

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

    result = cell.render(context)
    assert '/backoffice/submission/a-private-form/' not in result

    class MockUser2(MockUser):
        email = 'foo2@example.net'
    context['request'].user = MockUser2()

    result = cell.render(context)
    assert '/backoffice/submission/a-private-form/' in result