import datetime
import json
import logging
import os
import re
from unittest import mock

import pytest
import requests
from django.apps import apps
from django.conf import settings
from django.contrib.auth.models import User
from django.db import connection
from django.forms.widgets import Media
from django.template.exceptions import TemplateDoesNotExist
from django.test import override_settings
from django.test.client import RequestFactory
from django.test.utils import CaptureQueriesContext
from django.urls import reverse
from django.utils.encoding import force_bytes, force_text
from django.utils.timezone import now

from combo.data.library import get_cell_classes
from combo.data.models import (
    CellBase,
    ConfigJsonCell,
    FeedCell,
    JsonCell,
    LinkCell,
    LinkListCell,
    MenuCell,
    Page,
    TextCell,
    ValidityInfo,
)
from combo.utils import NothingInCacheException

from .test_manager import login

pytestmark = pytest.mark.django_db


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


def mock_json_response(content, **kwargs):
    content = force_bytes(content)
    text = force_text(content)
    return mock.Mock(content=content, text=text, json=lambda: json.loads(text), **kwargs)


def test_cell_reference():
    page = Page()
    page.save()

    cell = TextCell()
    cell.page = page
    cell.text = 'foobar'
    cell.order = 0
    cell.save()

    assert CellBase.get_cell(cell.get_reference()) == cell


def test_media():
    class TextCelleWithMedia(TextCell):
        class Media:
            js = ['coincoin.js']

        class Meta:
            # to prevent error in Models metaclass as the current module is not
            # in a registered applicatoin
            proxy = True
            app_label = 'data'

    cells = [TextCelleWithMedia() for i in range(3)]
    assert (
        force_text(sum((cell.media for cell in cells), Media()))
        == '<script src="/static/coincoin.js"></script>'
    )


def test_additional_label():
    page = Page()
    page.save()

    cell = TextCell()
    cell.page = page
    cell.text = '<p>foobar</p>'
    cell.order = 0
    cell.save()

    assert cell.get_additional_label() == 'foobar'

    cell = TextCell()
    cell.page = page
    cell.text = '<p>%s</p>' % 'foo' * 30
    cell.order = 0
    cell.save()

    assert len(cell.get_additional_label()) < 100
    assert '...' in cell.get_additional_label()


def test_text_cell_variadic_url():
    page = Page()
    page.save()

    cell = TextCell(page=page, order=0)
    cell.text = '<a href="{{test_url}}">test</a> <a href="/plop">test2</a> <img src="{{test_url}}"'
    cell.save()
    with override_settings(TEMPLATE_VARS={'test_url': 'http://example.net'}):
        ctx = {}
        assert 'href="http://example.net"' in cell.render(ctx)
        assert 'href="/plop"' in cell.render(ctx)
        assert 'src="http://example.net"' in cell.render(ctx)

    # consider unknown variables as empty
    assert 'href=""' in cell.render(ctx)
    assert 'href="/plop"' in cell.render(ctx)


def test_link_cell():
    page = Page(title='example page', slug='example-page')
    page.save()

    cell = LinkCell()
    cell.page = page
    cell.title = 'Example Site'
    cell.url = 'http://example.net/'
    cell.order = 0
    cell.save()

    assert cell.get_additional_label() == 'Example Site'

    ctx = {}
    assert cell.render(ctx).strip() == '<a href="http://example.net/">Example Site</a>'

    cell.title = ''
    cell.save()
    assert cell.render(ctx).strip() == '<a href="http://example.net/">http://example.net/</a>'

    cell.link_page = page
    cell.save()
    assert cell.render(ctx).strip() == '<a href="/example-page/">example page</a>'

    cell.title = 'altertitle'
    cell.save()
    assert cell.render(ctx).strip() == '<a href="/example-page/">altertitle</a>'

    cell.anchor = 'anchor'
    cell.save()
    assert cell.render(ctx).strip() == '<a href="/example-page/#anchor">altertitle</a>'

    cell.link_page = None
    cell.save()
    assert cell.render(ctx).strip() == '<a href="http://example.net/#anchor">altertitle</a>'


@pytest.mark.parametrize('bypass', [True, False])
def test_link_cell_validity(settings, bypass):
    page = Page.objects.create(title='example page', slug='example-page')
    cell = LinkCell.objects.create(
        page=page,
        title='Example Site',
        order=0,
        bypass_url_validity_check=bypass,
    )

    # no link defined
    if bypass:
        assert ValidityInfo.objects.exists() is False
    else:
        validity_info = ValidityInfo.objects.latest('pk')
        assert validity_info.invalid_reason_code == 'data_url_not_defined'
        assert validity_info.invalid_since is not None

    # no link defined but anchor set
    cell.anchor = 'plop'
    cell.save()
    assert ValidityInfo.objects.exists() is False

    # internal link - no check
    cell.link_page = page
    with mock.patch('combo.data.models.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=404)
        requests_get.return_value = mock_json
        cell.save()
    assert requests_get.call_args_list == []
    assert ValidityInfo.objects.exists() is False

    # external link
    cell.link_page = None
    cell.url = 'http://example.net/'
    with mock.patch('combo.data.models.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=404)
        requests_get.return_value = mock_json
        cell.save()
    if bypass:
        assert ValidityInfo.objects.exists() is False
    else:
        validity_info = ValidityInfo.objects.latest('pk')
        assert validity_info.invalid_reason_code == 'data_url_not_found'
        assert validity_info.invalid_since is not None

    with mock.patch('combo.data.models.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=200)
        requests_get.return_value = mock_json
        cell.save()
    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.data.models.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=500)
        requests_get.return_value = mock_json
        cell.save()
    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.data.models.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=400)
        requests_get.return_value = mock_json
        cell.save()
    if bypass:
        assert ValidityInfo.objects.exists() is False
    else:
        validity_info = ValidityInfo.objects.latest('pk')
        assert validity_info.invalid_reason_code == 'data_url_invalid'
        assert validity_info.invalid_since is not None

    # external link with a single variable
    cell.link_page = None
    cell.anchor = ''
    settings.TEMPLATE_VARS = {'var1': 'foo'}
    cell.url = 'http://foo?varone={{var1}}'
    with mock.patch('combo.data.models.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=200)
        requests_get.return_value = mock_json
        cell.save()
    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.data.models.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=404)
        requests_get.return_value = mock_json
        cell.save()
    if bypass:
        assert ValidityInfo.objects.exists() is False
    else:
        assert ValidityInfo.objects.exists() is True

    # external link with two variables
    settings.TEMPLATE_VARS = {'var1': 'foo', 'var2': 'bar'}
    cell.url = 'http://foo?varone={{var1}}&vartwo={{var2}}'
    with mock.patch('combo.data.models.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=404)
        requests_get.return_value = mock_json
        cell.save()
    assert ValidityInfo.objects.exists() is False


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

    cell = LinkListCell.objects.create(order=0, page=page)
    item = LinkCell.objects.create(
        page=page,
        placeholder=cell.link_placeholder,
        title='Example Site',
        url='http://example.net/',
        order=0,
        extra_css_class='foobar',
    )

    ctx = {'page_cells': [item]}
    assert '<ul><li class=" foobar"><a href="http://example.net/">Example Site</a></li></ul>' in cell.render(
        ctx
    )

    item.title = ''
    item.extra_css_class = ''
    assert '<ul><li class=""><a href="http://example.net/">http://example.net/</a></li></ul>' in cell.render(
        ctx
    )

    item.link_page = page
    assert '<ul><li class=""><a href="/example-page/">example page</a></li></ul>' in cell.render(ctx)

    item.title = 'altertitle'
    assert '<ul><li class=""><a href="/example-page/">altertitle</a></li></ul>' in cell.render(ctx)

    item.anchor = 'anchor'
    assert '<ul><li class=""><a href="/example-page/#anchor">altertitle</a></li></ul>' in cell.render(ctx)

    item.link_page = None
    assert '<ul><li class=""><a href="http://example.net/#anchor">altertitle</a></li></ul>' in cell.render(
        ctx
    )

    item2 = LinkCell.objects.create(
        page=page,
        placeholder=cell.link_placeholder,
        title='Example Site',
        url='http://example.net/',
        order=1,
    )
    ctx = {'page_cells': [item, item2]}
    assert 'class="add-more-items--button">+</a>' not in cell.render(ctx)
    cell.limit = 1
    assert 'class="add-more-items--button">+</a>' in cell.render(ctx)


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

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

    item.mark_as_valid()
    cell.check_validity()
    assert ValidityInfo.objects.exists() is False

    item.mark_as_invalid('foo_bar_reason')
    cell.check_validity()
    validity_info = ValidityInfo.objects.latest('pk')
    assert validity_info.invalid_reason_code == 'data_link_invalid'
    assert validity_info.invalid_since is not None
    validity_info.invalid_since = now() - datetime.timedelta(days=2)
    validity_info.save()
    request = RequestFactory().get('/')
    assert cell.is_visible(request)  # particular case: cell is visible


def test_feed_cell_validity(context):
    page = Page.objects.create(title='example page', slug='example-page')
    cell = FeedCell.objects.create(page=page, placeholder='content', order=1)

    cell.get_cell_extra_context(context)
    validity_info = ValidityInfo.objects.latest('pk')
    assert validity_info.invalid_reason_code == 'data_url_not_defined'
    assert validity_info.invalid_since is not None

    cell.url = 'http://example.net/'
    cell.save()
    with mock.patch('combo.data.models.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=404)
        requests_get.return_value = mock_json
        cell.get_cell_extra_context(context)
    validity_info = ValidityInfo.objects.latest('pk')
    assert validity_info.invalid_reason_code == 'data_url_not_found'
    assert validity_info.invalid_since is not None

    with mock.patch('combo.data.models.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=200, content='')
        requests_get.return_value = mock_json
        cell.get_cell_extra_context(context)
    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.data.models.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=500)
        requests_get.return_value = mock_json
        cell.get_cell_extra_context(context)
    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.data.models.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=400)
        requests_get.return_value = mock_json
        cell.get_cell_extra_context(context)
    validity_info = ValidityInfo.objects.latest('pk')
    assert validity_info.invalid_reason_code == 'data_url_invalid'
    assert validity_info.invalid_since is not None

    # check validity info is cleared when the cell is saved
    cell.save()
    assert ValidityInfo.objects.exists() is False


def test_manager_feed_cell_tabs(app, admin_user):
    page = Page.objects.create(title='example page', slug='example-page')
    FeedCell.objects.create(page=page, placeholder='content', order=1)
    app = login(app)
    resp = app.get('/manage/pages/%s/' % page.pk)

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


def test_menu_cell():
    Page.objects.all().delete()
    parent = Page.objects.create(
        title='Page1', slug='page1', template_name='standard', exclude_from_navigation=False
    )
    page = Page.objects.create(
        title='Page2', slug='page2', template_name='standard', parent=parent, exclude_from_navigation=False
    )
    page = Page.objects.create(
        title='Page3',
        slug='page3',
        template_name='standard',
        parent=parent,
        public=False,
        exclude_from_navigation=False,
    )
    cell = MenuCell.objects.create(root_page=parent, order=0, page=parent)
    request = RequestFactory().get('/page1/')
    request.user = None
    ctx = {'page': parent, 'request': request}
    assert 'menu-page2' in cell.render(ctx)
    assert 'menu-page3' not in cell.render(ctx)

    request.user = User(username='foo', email='foo@example.net')
    assert 'menu-page2' in cell.render(ctx)
    assert 'menu-page3' in cell.render(ctx)

    # check cell is deferred in skeletons if some pages are private
    ctx = {'page': parent, 'request': request, 'render_skeleton': True}
    with pytest.raises(NothingInCacheException):
        cell.render(ctx)

    # and that it's rendered directly if all pages are public
    page.public = True
    page.save()
    ctx = {'page': parent, 'request': request, 'render_skeleton': True}
    assert 'menu-page2' in cell.render(ctx)
    assert 'menu-page3' in cell.render(ctx)


def test_variant_templates():
    page = Page(title='example page', slug='example-page')
    page.save()

    cell = TextCell()
    cell.page = page
    cell.text = '<p>foobar</p>'
    cell.order = 0
    cell.save()

    ctx = {}
    assert cell.render(ctx).strip() == '<p>foobar</p>'

    templates_settings = [settings.TEMPLATES[0].copy()]
    templates_settings[0]['DIRS'] = ['%s/templates-1' % os.path.abspath(os.path.dirname(__file__))]
    with override_settings(TEMPLATES=templates_settings):
        assert cell.render(ctx).strip() == '<p>foobar</p>'
        cell.slug = 'foobar'
        cell.save()
        assert cell.render(ctx).strip() == '<div class="XXX"><p>foobar</p></div>'

    assert cell.render(ctx).strip() == '<p>foobar</p>'


def test_extra_template():
    page = Page(title='example page', slug='example-page')
    page.save()

    cell = TextCell()
    cell.page = page
    cell.text = '<p>foobar</p>'
    cell.order = 0
    cell.save()

    ctx = {}

    templates_settings = [settings.TEMPLATES[0].copy()]
    templates_settings[0]['DIRS'] = ['%s/templates-1' % os.path.abspath(os.path.dirname(__file__))]
    with override_settings(
        COMBO_CELL_TEMPLATES={
            'data_textcell': {
                'extra': {
                    'label': 'Extra',
                    'template': 'combo/cells/foobar/text-cell.html',
                    'extra-css-classes': 'plop',
                }
            }
        },
        TEMPLATES=templates_settings,
    ):
        cell.slug = ''
        cell.template_name = 'extra'
        cell.save()
        assert cell.render(ctx).strip() == '<div class="XXX"><p>foobar</p></div>'
        assert 'plop' in cell.css_class_names


def mocked_request(*args, **kwargs):
    pass


def test_json_cell(caplog):
    caplog.set_level(logging.DEBUG)
    page = Page(title='example page', slug='example-page')
    page.save()

    cell = JsonCell()
    cell.page = page
    cell.url = 'http://example.net/'
    cell.title = 'Example Site'
    cell.order = 0
    cell.save()

    cell._json_content = None
    assert cell.default_template_name == 'combo/json-error-cell.html'

    cell._json_content = {}
    assert cell.default_template_name == 'combo/json-cell.html'

    cell._json_content = {'data': []}
    assert cell.default_template_name == 'combo/json-cell.html'

    cell._json_content = {'data': [{'url': 'xxx', 'text': 'xxx'}]}
    assert cell.default_template_name == 'combo/json-list-cell.html'

    cell._json_content = {'data': [{'foo': 'xxx', 'bar': 'xxx'}]}
    assert cell.default_template_name == 'combo/json-cell.html'

    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': [{'url': 'xxx', 'text': 'xxx'}]}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        context = cell.get_cell_extra_context({})
        assert context['json'] == data
        assert context['json_url'] == 'http://example.net/'
        assert context['json_status'] == 200
        assert 'json_error' not in context

        requests_get.return_value = mock_json_response(content='', status_code=204)  # 204 : No Content
        context = cell.get_cell_extra_context({})
        assert context['json'] is None
        assert context['json_url'] == 'http://example.net/'
        assert context['json_status'] == 204
        assert 'json_error' not in context

        requests_get.return_value = mock_json_response(content='not found', status_code=404, headers={})
        context = cell.get_cell_extra_context({})
        assert context['json'] is None
        assert context['json_url'] == 'http://example.net/'
        assert context['json_status'] == 404
        assert 'json_error' not in context

        requests_get.return_value = mock_json_response(
            content=json.dumps(data), status_code=404, headers={'content-type': 'application/json'}
        )
        context = cell.get_cell_extra_context({})
        assert context['json'] is None
        assert context['json_url'] == 'http://example.net/'
        assert context['json_status'] == 404
        assert context['json_error'] == data

        def mocked_requests_connection_error(*args, **kwargs):
            raise requests.ConnectionError('boom')

        requests_get.side_effect = mocked_requests_connection_error
        context = cell.get_cell_extra_context({})
        assert context['json'] is None
        assert context['json_status'] == -1
        assert context['json_url'] == 'http://example.net/'
        assert context['json_error'] == 'boom'
        assert isinstance(context['json_exception'], requests.ConnectionError)

        cell.url = ''  # no URL -> no request, no data, no status
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        context = cell.get_cell_extra_context({})
        assert context['json'] is None
        assert context['json_url'] == ''
        assert 'json_status' not in context
        assert 'json_error' not in context

    with pytest.raises(NothingInCacheException):
        cell.url = 'http://test3'
        cell.render({})

    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': [{'url': 'http://a.b', 'text': 'xxx'}]}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        cell.url = 'http://test4'
        result = cell.render({'synchronous': True})
        assert 'http://a.b' in result
        assert requests_get.call_count == 1

        cell.template_string = '{{json.data.0.text}}'
        result = cell.render({'synchronous': True})
        assert result == 'xxx'

    with mock.patch('combo.utils.requests.get') as requests_get:
        requests_get.return_value = mock_json_response(content='garbage', status_code=200)
        cell.url = 'http://test5'
        result = cell.render({'synchronous': True})
        assert result == ''

        context = cell.get_cell_extra_context({})
        assert context['json'] is None
        assert context['json_url'] == 'http://test5'
        assert context['json_status'] == 200
        assert context['json_error'] == 'invalid_json'

    # URL is a template, using [variables]
    cell.cache_duration = 10
    data = {'data': [{'url': 'xxx', 'text': 'xxx'}]}
    cell.url = 'http://testuser?[foobar]'
    with mock.patch('combo.utils.requests.get') as requests_get:
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        context = cell.get_cell_extra_context({'foobar': 'barfoo'})
        assert context['json'] == data
        assert context['json_url'] == 'http://testuser?barfoo'
        assert context['json_status'] == 200
        assert requests_get.call_args[0][0] == 'http://testuser?barfoo'
        assert requests_get.call_args[1]['cache_duration'] == 10
        assert requests_get.call_count == 1
    caplog.clear()
    with mock.patch('combo.utils.requests.get') as requests_get:
        context = cell.get_cell_extra_context({})
        # can't get URL, 'foobar' variable is missing
        assert context['json'] is None
        assert requests_get.call_count == 0
        assert caplog.record_tuples == [
            (
                'combo.data.models',
                logging.DEBUG,
                'error in templated URL (http://testuser?[foobar]): unknown variable foobar',
            )
        ]
    request = RequestFactory().get('/')
    request.user = User(username='foo', email='foo@example.net')
    cell.url = 'http://testuser?email=[user_email]'
    with mock.patch('combo.utils.requests.get') as requests_get:
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        context = cell.get_cell_extra_context({'request': request})
        assert context['json'] == data
        assert context['json_url'] == 'http://testuser?email=foo%40example.net'
        assert requests_get.call_count == 1
        assert requests_get.call_args[0][0] == 'http://testuser?email=foo%40example.net'
        assert requests_get.call_args[1]['cache_duration'] == 10

    # URL is a template
    cell.url = 'http://testuser?{{ concerned_user|name_id }}'
    caplog.clear()
    with mock.patch('combo.utils.requests.get') as requests_get:
        context = cell.get_cell_extra_context({})
        # can't get URL, variable is missing
        assert context['json'] is None
        assert requests_get.call_count == 0
        assert caplog.record_tuples == [
            (
                'combo.data.models',
                logging.DEBUG,
                'error in templated URL (http://testuser?{{ concerned_user|name_id }}): name_id',
            )
        ]

    cell.url = 'http://testuser?{% for %}'
    caplog.clear()
    with mock.patch('combo.utils.requests.get') as requests_get:
        context = cell.get_cell_extra_context({})
        # can't get URL, variable is missing
        assert context['json'] is None
        assert requests_get.call_count == 0
        assert len(caplog.records) == 1
        assert caplog.record_tuples == [
            (
                'combo.data.models',
                logging.ERROR,
                'error in templated URL (http://testuser?{% for %}): syntax error',
            )
        ]


def test_json_cell_with_varnames(app):
    page = Page(title='example page', slug='index')
    page.save()

    cell = JsonCell()
    cell.page = page
    cell.title = 'Example Site'
    cell.order = 0
    cell.varnames_str = 'var1, var2, '
    cell.url = 'http://foo?varone=[var1]&vartwo=[var2]'
    cell.template_string = '/var1={{var1}}/var2={{var2}}/'
    cell.save()

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

    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        url = reverse(
            'combo-public-ajax-page-cell', kwargs={'page_pk': page.id, 'cell_reference': cell.get_reference()}
        )
        resp = app.get(url + '?var1=foo&var2=bar')  # request query string is here
        assert requests_get.call_count == 1
        assert requests_get.call_args[0][0] == 'http://foo?varone=foo&vartwo=bar'
        assert '/var1=foo/' in resp.text
        assert '/var2=bar/' in resp.text


def test_json_cell_make_public_url(app):
    page = Page(title='example page', slug='index')
    page.save()

    cell = JsonCell()
    cell.page = page
    cell.title = 'Example Site'
    cell.order = 0
    cell.url = 'https://example.net'

    # url from known_services
    cell.template_string = '{% make_public_url url="http://127.0.0.1:8999/" %}'
    cell.save()

    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        url = reverse(
            'combo-public-ajax-page-cell', kwargs={'page_pk': page.id, 'cell_reference': cell.get_reference()}
        )
        resp = app.get(url)
        assert '/api/wcs/file/' in resp.text
        assert 'http://127.0.0.1:8999' not in resp.text

    # url from unknown service
    cell.template_string = '{% make_public_url url="https://example.net" %}'
    cell.save()

    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        url = reverse(
            'combo-public-ajax-page-cell', kwargs={'page_pk': page.id, 'cell_reference': cell.get_reference()}
        )
        resp = app.get(url)
        assert 'https://example.net' in resp.text
        assert '/api/wcs/file/' not in resp.text

    # url with empty string
    cell.template_string = 'X{% make_public_url url="" %}Y'
    cell.save()

    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        url = reverse(
            'combo-public-ajax-page-cell', kwargs={'page_pk': page.id, 'cell_reference': cell.get_reference()}
        )
        resp = app.get(url)
        assert 'XY' in resp.text
        assert '/api/wcs/file/' not in resp.text

    # url as None
    cell.template_string = 'X{% make_public_url url=None %}Y'
    cell.save()

    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        url = reverse(
            'combo-public-ajax-page-cell', kwargs={'page_pk': page.id, 'cell_reference': cell.get_reference()}
        )
        resp = app.get(url)
        assert 'XNoneY' in resp.text
        assert '/api/wcs/file/' not in resp.text

    # url as "None" as string
    cell.template_string = '{% make_public_url url="None" %}'
    cell.save()

    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        url = reverse(
            'combo-public-ajax-page-cell', kwargs={'page_pk': page.id, 'cell_reference': cell.get_reference()}
        )
        resp = app.get(url)
        assert resp.text == 'None'


def test_json_cell_validity(context):
    page = Page.objects.create(title='example page', slug='example-page')
    cell = JsonCell.objects.create(
        page=page,
        placeholder='content',
        order=1,
        varnames_str='var1, var2, ',
        url='http://foo?varone=[var1]&vartwo=[var2]',
    )

    with mock.patch('combo.data.models.requests.get') as requests_get:
        cell.get_cell_extra_context(context)
    assert requests_get.call_args_list == []  # invalid context
    assert ValidityInfo.objects.exists() is False

    context['synchronous'] = True  # to get fresh content
    cell.varnames_str = ''
    cell.url = 'http://foo'
    with mock.patch('combo.utils.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=404)
        requests_get.side_effect = [mock_json]
        cell.get_cell_extra_context(context)
    validity_info = ValidityInfo.objects.latest('pk')
    assert validity_info.invalid_reason_code == 'data_url_not_found'
    assert validity_info.invalid_since is not None

    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        cell.get_cell_extra_context(context)
    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.utils.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=500)
        requests_get.return_value = mock_json
        cell.get_cell_extra_context(context)
    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.utils.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=400)
        requests_get.return_value = mock_json
        cell.get_cell_extra_context(context)
    validity_info = ValidityInfo.objects.latest('pk')
    assert validity_info.invalid_reason_code == 'data_url_invalid'
    assert validity_info.invalid_since is not None

    # url with a single variable
    context['var1'] = 'foo'
    cell.varnames_str = 'var1'
    cell.url = 'http://foo?varone={{var1}}'
    with mock.patch('combo.utils.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 ValidityInfo.objects.exists() is False

    with mock.patch('combo.utils.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=404)
        requests_get.side_effect = [mock_json]
        cell.get_cell_extra_context(context)
    assert ValidityInfo.objects.exists() is True

    # check validity info is cleared when the cell is saved
    cell.save()
    assert ValidityInfo.objects.exists() is False

    # url with two variables
    context['var2'] = 'bar'
    cell.varnames_str = 'var1, var2'
    cell.url = 'http://foo?varone={{var1}}&vartwo={{var2}}'
    with mock.patch('combo.utils.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=404)
        requests_get.side_effect = [mock_json]
        cell.get_cell_extra_context(context)
    assert ValidityInfo.objects.exists() is False


def test_manager_json_cell_tabs(app, admin_user):
    page = Page.objects.create(title='example page', slug='example-page')
    JsonCell.objects.create(
        page=page,
        placeholder='content',
        order=1,
        varnames_str='var1, var2, ',
        url='http://foo?varone=[var1]&vartwo=[var2]',
    )
    app = login(app)
    resp = app.get('/manage/pages/%s/' % page.pk)

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


def test_config_json_cell():
    page = Page(title='example page', slug='example-page')
    page.save()

    request = RequestFactory().get('/')

    with override_settings(JSON_CELL_TYPES={'foobar': {'name': 'Foobar', 'url': 'http://test/'}}):
        cell = ConfigJsonCell()
        cell.key = 'foobar'
        cell.parameters = {'blah': 'plop'}
        assert cell.get_label() == 'Foobar'
        assert cell.url == 'http://test/'
        assert cell.default_template_name == 'combo/json/foobar.html'
        assert cell.css_class_names.split() == ['config-json-cell', 'configjsoncell', 'foobar']

        with mock.patch('combo.utils.requests.get') as requests_get:
            requests_get.return_value = mock_json_response(
                content=json.dumps({'hello': 'world'}), status_code=200
            )
            context = cell.get_cell_extra_context({'request': request})
            assert context['json'] == {'hello': 'world'}
            assert context['json_url'] == 'http://test/'
            assert context['json_status'] == 200
            assert context['parameters'] == {'blah': 'plop'}
            assert context['blah'] == 'plop'

    with override_settings(
        JSON_CELL_TYPES={'foobar': {'name': 'Foobar', 'url': 'http://test/', 'cache_duration': 10}}
    ):
        cell = ConfigJsonCell()
        cell.key = 'foobar'
        cell.parameters = {'blah': 'plop'}
        assert cell.get_label() == 'Foobar'
        assert cell.url == 'http://test/'
        assert cell.default_template_name == 'combo/json/foobar.html'
        assert cell.cache_duration == 10


def test_config_json_cell_with_varnames(app):
    page = Page(title='example page', slug='index')
    page.save()

    templates_settings = [settings.TEMPLATES[0].copy()]
    templates_settings[0]['DIRS'] = ['%s/templates-1' % os.path.abspath(os.path.dirname(__file__))]
    with override_settings(
        JSON_CELL_TYPES={
            'test-config-json-cell': {
                'name': 'Foobar',
                'url': 'http://foo?varone=[var1]&vartwo=[var2]',
                'varnames': ['var1', 'var2'],
            }
        },
        TEMPLATES=templates_settings,
    ):
        cell = ConfigJsonCell()
        cell.key = 'test-config-json-cell'
        cell.page = page
        cell.title = 'Example Site'
        cell.order = 0
        cell.save()
        assert cell.varnames == ['var1', 'var2']

        with mock.patch('combo.utils.requests.get') as requests_get:
            data = {'data': []}
            requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
            url = reverse(
                'combo-public-ajax-page-cell',
                kwargs={'page_pk': page.id, 'cell_reference': cell.get_reference()},
            )
            resp = app.get(url + '?var1=foo&var2=bar')  # request query string is here
            assert requests_get.call_count == 1
            assert requests_get.call_args[0][0] == 'http://foo?varone=foo&vartwo=bar'
            assert '/var1=foo/' in resp.text
            assert '/var2=bar/' in resp.text

            resp = app.get(url + '?var2=plop')  # use var1 default value
            assert requests_get.call_count == 1  # no request, var1 is missing
            assert '/var1=/' in resp.text
            assert '/var2=plop/' in resp.text

            cell.parameters = {'var1': 'defaultvalue1'}
            cell.save()
            resp = app.get(url + '?var2=plop')  # use var1 default value
            assert requests_get.call_count == 2
            assert requests_get.call_args[0][0] == 'http://foo?varone=defaultvalue1&vartwo=plop'
            assert '/var1=defaultvalue1/' in resp.text
            assert '/var2=plop/' in resp.text


def test_config_json_cell_with_param_in_url(app):
    page = Page(title='example page', slug='index')
    page.save()

    templates_settings = [settings.TEMPLATES[0].copy()]
    templates_settings[0]['DIRS'] = ['%s/templates-1' % os.path.abspath(os.path.dirname(__file__))]
    with override_settings(
        JSON_CELL_TYPES={
            'test-config-json-cell': {
                'name': 'Foobar',
                'url': 'http://foo?var=[identifier]',
                'log_errors': False,
                'timeout': 42,
                'form': [{"varname": "identifier", "type": "string", "label": "Identifier"}],
            }
        },
        TEMPLATES=templates_settings,
    ):
        cell = ConfigJsonCell()
        cell.key = 'test-config-json-cell'
        cell.parameters = {'identifier': 'plop'}
        cell.page = page
        cell.title = 'Example Site'
        cell.order = 0
        cell.save()

        with mock.patch('combo.utils.requests.get') as requests_get:
            data = {'data': []}
            requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
            url = reverse(
                'combo-public-ajax-page-cell',
                kwargs={'page_pk': page.id, 'cell_reference': cell.get_reference()},
            )
            app.get(url)
            assert requests_get.call_count == 1
            assert requests_get.call_args[0][0] == 'http://foo?var=plop'
            assert requests_get.call_args[-1]['log_errors'] is False
            assert requests_get.call_args[-1]['timeout'] == 42


def test_config_json_cell_with_template_string(settings, context):
    settings.JSON_CELL_TYPES = {
        'test-config-json-cell': {
            'name': 'Foobar',
            'url': 'http://foo',
            'form': [
                {"varname": "identifier", "type": "string", "label": "Identifier"},
                {"varname": "template_string", "type": "text", "label": "Template"},
            ],
        },
    }
    page = Page.objects.create(title='example page', slug='example-page')
    cell = ConfigJsonCell.objects.create(
        page=page,
        placeholder='content',
        order=1,
        key='test-config-json-cell',
        parameters={'identifier': 'plop', 'template_string': 'Foo Bar {{ identifier }}'},
    )

    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        assert cell.render({}) == 'Foo Bar plop'

    settings.JSON_CELL_TYPES = {  # template_string is not defined anymore
        'test-config-json-cell': {
            'name': 'Foobar',
            'url': 'http://foo',
            'form': [
                {"varname": "identifier", "type": "string", "label": "Identifier"},
            ],
        },
    }
    cell = ConfigJsonCell.objects.get(pk=cell.pk)  # reload cell
    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        with pytest.raises(TemplateDoesNotExist):
            cell.render({})


def test_config_json_cell_with_global(settings, app):
    settings.JSON_CELL_TYPES = {
        'test-config-json-cell': {
            'name': 'Foobar',
            'url': 'http://foo',
            'make_global': 'new_global_context',
            'form': [
                {"varname": "template_string", "type": "text", "label": "Template"},
            ],
        },
        'test-config-json-cell-2': {
            'name': 'Foobar 2',
            'url': 'http://foo',
            'form': [
                {"varname": "template_string", "type": "text", "label": "Template"},
            ],
        },
    }
    page = Page.objects.create(title='example page', slug='example-page')
    cell1 = ConfigJsonCell.objects.create(
        page=page,
        placeholder='content',
        order=1,
        key='test-config-json-cell',
        parameters={'template_string': 'Foo Bar'},
    )
    cell2 = ConfigJsonCell.objects.create(
        page=page,
        placeholder='content',
        order=2,
        key='test-config-json-cell-2',
        parameters={'template_string': 'Foo Bar'},
    )
    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        url = reverse(
            'combo-public-ajax-page-cell',
            kwargs={'page_pk': page.pk, 'cell_reference': cell1.get_reference()},
        )
        resp = app.get(url)
        assert resp.context['new_global_context'] == data
        url = reverse(
            'combo-public-ajax-page-cell',
            kwargs={'page_pk': page.pk, 'cell_reference': cell2.get_reference()},
        )
        resp = app.get(url)
        assert resp.context['new_global_context'] == data


def test_config_json_cell_with_repeat(settings, app):
    settings.JSON_CELL_TYPES = {
        'test-config-json-cell': {
            'name': 'Foobar',
            'url': 'http://foo',
            'form': [
                {"varname": "template_string", "type": "text", "label": "Template"},
            ],
        },
        'test-config-json-cell-2': {
            'name': 'Foobar 2',
            'url': 'http://foo',
            'repeat': '3',
            'form': [
                {"varname": "template_string", "type": "text", "label": "Template"},
            ],
        },
    }
    page = Page.objects.create(title='example page', slug='example-page')
    cell1 = ConfigJsonCell.objects.create(
        page=page,
        placeholder='content',
        order=1,
        key='test-config-json-cell',
        parameters={'template_string': 'Foo Bar'},
    )
    cell2 = ConfigJsonCell.objects.create(
        page=page,
        placeholder='content',
        order=2,
        key='test-config-json-cell-2',
        parameters={'template_string': 'Foo Bar {{ repeat_index }}'},
    )

    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        resp = app.get(page.get_online_url())
        assert len(resp.context['cells']) == 4
        assert resp.context['cells'][0].pk == cell1.pk
        extra_ctx = re.findall(r'data-extra-context="(.*)"', resp.text)
        cell_url = reverse(
            'combo-public-ajax-page-cell',
            kwargs={'page_pk': page.pk, 'cell_reference': cell2.get_reference()},
        )
        for i in range(0, 3):
            assert resp.context['cells'][i + 1].pk == cell2.pk
            assert resp.context['cells'][i + 1].repeat_index == i
            cell_resp = app.get(cell_url + '?ctx=' + extra_ctx[i + 1])
            assert cell_resp.context['repeat_index'] == i
            assert cell_resp.text == 'Foo Bar %s' % i

    # repeat: not an int
    settings.JSON_CELL_TYPES['test-config-json-cell-2']['repeat'] = 'foo'
    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        resp = app.get(page.get_online_url())
        assert len(resp.context['cells']) == 2

    # repeat: template error
    settings.JSON_CELL_TYPES['test-config-json-cell-2']['repeat'] = '{% foo %}'
    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        resp = app.get(page.get_online_url())
        assert len(resp.context['cells']) == 2


def test_config_json_cell_validity(settings, context):
    settings.JSON_CELL_TYPES = {
        'test-config-json-cell': {
            'name': 'Foobar',
            'url': 'http://foo?varone=[var1]&vartwo=[var2]',
            'varnames': ['var1', 'var2'],
        },
    }
    templates_settings = [settings.TEMPLATES[0].copy()]
    templates_settings[0]['DIRS'] = ['%s/templates-1' % os.path.abspath(os.path.dirname(__file__))]
    settings.TEMPLATES = templates_settings

    page = Page.objects.create(title='example page', slug='example-page')
    cell = ConfigJsonCell.objects.create(
        page=page,
        placeholder='content',
        order=1,
        key='test-config-json-cell',
        parameters={'identifier': 'plop'},
    )
    assert cell.varnames == ['var1', 'var2']

    with mock.patch('combo.data.models.requests.get') as requests_get:
        cell.get_cell_extra_context(context)
    assert requests_get.call_args_list == []  # invalid context
    assert ValidityInfo.objects.exists() is False

    context['synchronous'] = True  # to get fresh content
    settings.JSON_CELL_TYPES['test-config-json-cell']['url'] = 'http://foo'
    settings.JSON_CELL_TYPES['test-config-json-cell']['varnames'] = []
    with mock.patch('combo.utils.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=404)
        requests_get.side_effect = [mock_json]
        cell.get_cell_extra_context(context)
    validity_info = ValidityInfo.objects.latest('pk')
    assert validity_info.invalid_reason_code == 'data_url_not_found'
    assert validity_info.invalid_since is not None

    with mock.patch('combo.utils.requests.get') as requests_get:
        data = {'data': []}
        requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
        cell.get_cell_extra_context(context)
    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.utils.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=500)
        requests_get.return_value = mock_json
        cell.get_cell_extra_context(context)
    assert ValidityInfo.objects.exists() is False

    with mock.patch('combo.utils.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=400)
        requests_get.return_value = mock_json
        cell.get_cell_extra_context(context)
    validity_info = ValidityInfo.objects.latest('pk')
    assert validity_info.invalid_reason_code == 'data_url_invalid'
    assert validity_info.invalid_since is not None

    # url with a single variable
    context['var1'] = 'foo'
    settings.JSON_CELL_TYPES['test-config-json-cell']['varnames'] = ['var1']
    settings.JSON_CELL_TYPES['test-config-json-cell']['url'] = 'http://foo?varone={{var1}}'
    with mock.patch('combo.utils.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 ValidityInfo.objects.exists() is False

    with mock.patch('combo.utils.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=404)
        requests_get.side_effect = [mock_json]
        cell.get_cell_extra_context(context)
    assert ValidityInfo.objects.exists() is True

    # url with two variables
    context['var2'] = 'bar'
    settings.JSON_CELL_TYPES['test-config-json-cell']['varnames'] = ['var1', 'var2']
    settings.JSON_CELL_TYPES['test-config-json-cell']['url'] = 'http://foo?varone={{var1}}&vartwo={{var2}}'
    with mock.patch('combo.utils.requests.get') as requests_get:
        mock_json = mock.Mock(status_code=404)
        requests_get.side_effect = [mock_json]
        cell.get_cell_extra_context(context)
    assert ValidityInfo.objects.exists() is False


def test_json_force_async():
    cell = JsonCell()
    cell.url = 'http://example.net/test-force-async'
    cell.template_string = '{{json.hello}}'
    cell.force_async = True
    with mock.patch('combo.utils.requests_wrapper.RequestsSession.request') as requests_get:
        requests_get.return_value = mock_json_response(
            content=json.dumps({'hello': 'world'}), status_code=200
        )
        with pytest.raises(NothingInCacheException):
            cell.render({})
        assert cell.render({'synchronous': True}) == 'world'
        # check force async is effective
        with pytest.raises(NothingInCacheException):
            cell.render({})
        # disable force_async
        cell.force_async = False
        assert cell.render({}) == 'world'

    cell = JsonCell()
    cell.url = 'http://example.net/test-force-async-2'
    cell.template_string = '{{json.hello}}'
    cell.force_async = False
    with mock.patch('combo.utils.requests_wrapper.RequestsSession.request') as requests_get:
        requests_get.return_value = mock_json_response(
            content=json.dumps({'hello': 'world2'}), status_code=200
        )
        # raise if nothing in cache
        with pytest.raises(NothingInCacheException):
            cell.render({})
        # force stuff in cache
        assert cell.render({'synchronous': True}) == 'world2'
        # rerun with stuff in cache
        assert cell.render({}) == 'world2'


def test_config_json_cell_additional_url(app):
    page = Page(title='example page', slug='index')
    page.save()

    templates_settings = [settings.TEMPLATES[0].copy()]
    templates_settings[0]['DIRS'] = ['%s/templates-1' % os.path.abspath(os.path.dirname(__file__))]
    with override_settings(
        JSON_CELL_TYPES={
            'test-config-json-cell-2': {
                'name': 'Foobar',
                'url': 'http://foo',
                'additional-data': [
                    {'key': 'plop', 'url': 'http://bar', 'log_errors': False, 'timeout': 42},
                ],
            }
        },
        TEMPLATES=templates_settings,
    ):
        cell = ConfigJsonCell()
        cell.key = 'test-config-json-cell-2'
        cell.page = page
        cell.title = 'Example Site'
        cell.order = 0
        cell.save()

        with mock.patch('combo.utils.requests.get') as requests_get:
            data = {'data': 'toto'}
            requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
            url = reverse(
                'combo-public-ajax-page-cell',
                kwargs={'page_pk': page.id, 'cell_reference': cell.get_reference()},
            )
            resp = app.get(url)
            assert resp.text.strip() == '/var1=toto/var2=toto/'
            assert len(requests_get.mock_calls) == 2
            assert requests_get.mock_calls[0][1][0] == 'http://foo'
            assert requests_get.mock_calls[0][-1]['log_errors'] is True
            assert requests_get.mock_calls[0][-1]['timeout'] is None
            assert requests_get.mock_calls[1][1][0] == 'http://bar'
            assert requests_get.mock_calls[1][-1]['log_errors'] is False
            assert requests_get.mock_calls[1][-1]['timeout'] == 42

        with mock.patch('combo.utils.requests.get') as requests_get:
            data = {'data': 'toto'}
            requests_get.return_value = mock_json_response(
                content=json.dumps(data), status_code=404, headers={'content-type': 'application/json'}
            )
            url = reverse(
                'combo-public-ajax-page-cell',
                kwargs={'page_pk': page.id, 'cell_reference': cell.get_reference()},
            )
            resp = app.get(url)
            assert resp.text.strip() == '/var1=/var2=/'
            assert len(requests_get.mock_calls) == 2
            assert requests_get.mock_calls[0][1][0] == 'http://foo'
            assert requests_get.mock_calls[1][1][0] == 'http://bar'
            context = cell.get_cell_extra_context({})
            assert context['json'] is None
            assert context['json_url'] == 'http://foo'
            assert context['json_status'] == 404
            assert context['json_error'] == data
            assert context['plop'] is None
            assert context['plop_url'] == 'http://bar'
            assert context['plop_status'] == 404
            assert context['plop_error'] == data

        with mock.patch('combo.utils.requests.get') as requests_get:
            data = {'data': 'toto'}
            requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
            context = cell.get_cell_extra_context({})
            assert context['json'] == data
            assert context['json_url'] == 'http://foo'
            assert context['json_status'] == 200
            assert 'json_error' not in context
            assert context['plop'] == data
            assert context['plop_url'] == 'http://bar'
            assert context['plop_status'] == 200
            assert 'plop_error' not in context

    # additional-data url depends on others results, with Django-syntax URL
    with override_settings(
        JSON_CELL_TYPES={
            'test-config-json-cell-2': {
                'name': 'Foobar',
                'url': 'http://foo',
                'additional-data': [
                    {'key': 'plop', 'url': 'http://{{json.data}}', 'log_errors': False, 'timeout': 42},
                    {
                        'key': 'plop2',
                        'url': '{% if plop %}http://{{json.data}}/{{plop.data}}{% endif %}',
                        'log_errors': False,
                        'timeout': 10,
                    },
                ],
            }
        },
        TEMPLATES=templates_settings,
    ):
        cell = ConfigJsonCell()
        cell.key = 'test-config-json-cell-2'
        cell.page = page
        cell.title = 'Example Site'
        cell.order = 0
        cell.save()

        data = {'data': 'bar'}

        with mock.patch('combo.utils.requests.get') as requests_get:
            requests_get.return_value = mock_json_response(content=json.dumps(data), status_code=200)
            url = reverse(
                'combo-public-ajax-page-cell',
                kwargs={'page_pk': page.id, 'cell_reference': cell.get_reference()},
            )
            resp = app.get(url)
            assert resp.text.strip() == '/var1=bar/var2=bar/'
            assert len(requests_get.mock_calls) == 3
            assert requests_get.mock_calls[0][1][0] == 'http://foo'
            assert requests_get.mock_calls[0][-1]['log_errors'] is True
            assert requests_get.mock_calls[0][-1]['timeout'] is None
            assert requests_get.mock_calls[1][1][0] == 'http://bar'
            assert requests_get.mock_calls[1][-1]['log_errors'] is False
            assert requests_get.mock_calls[1][-1]['timeout'] == 42
            assert requests_get.mock_calls[2][1][0] == 'http://bar/bar'
            assert requests_get.mock_calls[2][-1]['log_errors'] is False
            assert requests_get.mock_calls[2][-1]['timeout'] == 10
            context = cell.get_cell_extra_context({})
            assert context['json'] == data
            assert context['json_url'] == 'http://foo'
            assert context['json_status'] == 200
            assert context['plop'] == data
            assert context['plop_url'] == 'http://bar'
            assert context['plop_status'] == 200
            assert context['plop2'] == data
            assert context['plop2_url'] == 'http://bar/bar'
            assert context['plop2_status'] == 200

        with mock.patch('combo.utils.requests.get') as requests_get:
            requests_get.return_value = mock_json_response(
                content=json.dumps(data), status_code=404, headers={'content-type': 'application/json'}
            )
            url = reverse(
                'combo-public-ajax-page-cell',
                kwargs={'page_pk': page.id, 'cell_reference': cell.get_reference()},
            )
            resp = app.get(url)
            assert resp.text.strip() == '/var1=/var2=/'
            # can not create plop and plop2 url: only one request for "json"
            assert len(requests_get.mock_calls) == 2
            assert requests_get.mock_calls[0][1][0] == 'http://foo'
            context = cell.get_cell_extra_context({})
            assert context['json'] is None
            assert context['json_url'] == 'http://foo'
            assert context['json_status'] == 404
            assert context['json_error'] == data
            assert context['plop'] is None
            assert context['plop_url'] == 'http://'
            assert context['plop_status'] == 404
            assert context['plop_error'] == data
            # plop2 url is empty, no request: None value, no status
            assert context['plop2'] is None
            assert context['plop2_url'] == ''
            assert 'plop2_status' not in context
            assert 'plop2_error' not in context


def test_config_json_invalid_key_cell():
    page = Page(title='example page', slug='example-page')
    page.save()

    with override_settings(JSON_CELL_TYPES={'foobar': {'name': 'Foobar', 'url': 'http://test/'}}):
        cell = ConfigJsonCell()
        cell.key = 'foobar'
        cell.parameters = {'blah': 'plop'}
        cell.page = page
        cell.order = 0
        cell.save()
        assert len(page.get_cells()) == 1

    assert len(page.get_cells()) == 0


def test_page_cell_placeholder_restricted_visibility(app, admin_user):
    page = Page(title='Test', slug='test', template_name='standard')
    page.save()
    json_cell = JsonCell(page=page, placeholder='content', order=0, url='http://example.com')
    json_cell.template_string = '{% placeholder "foobar" name="Foobar" %}'
    json_cell.save()

    TextCell(
        page=page, placeholder='foobar', text='<p>Public text</p>', order=0, restricted_to_unlogged=True
    ).save()
    TextCell(page=page, placeholder='foobar', text='<p>Private text</p>', order=1, public=False).save()

    resp = app.get(
        reverse(
            'combo-public-ajax-page-cell',
            kwargs={'page_pk': page.pk, 'cell_reference': json_cell.get_reference()},
        )
    )

    assert "<p>Public text</p>" in resp.text
    assert "<p>Private text</p>" not in resp.text

    app = login(app)
    resp = app.get(
        reverse(
            'combo-public-ajax-page-cell',
            kwargs={'page_pk': page.pk, 'cell_reference': json_cell.get_reference()},
        )
    )

    assert "<p>Public text</p>" not in resp.text
    assert "<p>Private text</p>" in resp.text


def test_related_cell_types_tracking():
    page = Page(title='example page', slug='example-page')
    page.save()
    assert page.related_cells['cell_types'] == []

    TextCell(page=page, placeholder='content', order=0, text='hello').save()
    assert Page.objects.get(id=page.id).related_cells['cell_types'] == ['data_textcell']

    TextCell(page=page, placeholder='content', order=1, text='hello').save()
    assert Page.objects.get(id=page.id).related_cells['cell_types'] == ['data_textcell']

    LinkCell(page=page, placeholder='content', order=0, title='Test', url='http://example.net').save()
    assert set(Page.objects.get(id=page.id).related_cells['cell_types']) == {'data_textcell', 'data_linkcell'}

    with CaptureQueriesContext(connection) as ctx:
        assert len(CellBase.get_cells(page=Page.objects.get(id=page.id))) == 3
        assert len(ctx.captured_queries) == 1 + 2

    TextCell.objects.get(order=1).delete()
    assert set(Page.objects.get(id=page.id).related_cells['cell_types']) == {'data_textcell', 'data_linkcell'}

    TextCell.objects.get(order=0).delete()
    assert set(Page.objects.get(id=page.id).related_cells['cell_types']) == {'data_linkcell'}

    with CaptureQueriesContext(connection) as ctx:
        assert len(CellBase.get_cells(page=Page.objects.get(id=page.id))) == 1
        assert len(ctx.captured_queries) == 1 + 1

    # remove tracker, check it is rebuilt correctly
    page.related_cells = {}
    page.save()

    with CaptureQueriesContext(connection) as ctx:
        assert len(CellBase.get_cells(page=Page.objects.get(id=page.id))) == 1
        assert len(ctx.captured_queries) == len(get_cell_classes())

    Page.objects.get(id=page.id).get_cells()

    TextCell(page=page, placeholder='content', order=0, text='hello').save()
    assert set(Page.objects.get(id=page.id).related_cells['cell_types']) == {'data_textcell', 'data_linkcell'}


def test_link_list_cell_duplicate():
    page = Page.objects.create(title='xxx', slug='new', template_name='standard')
    cell = LinkListCell.objects.create(order=0, page=page)
    item = LinkCell.objects.create(
        page=page,
        placeholder=cell.link_placeholder,
        title='Example Site',
        url='http://example.net/',
        link_page=page,
        order=1,
    )

    new_cell = cell.duplicate()
    assert LinkCell.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.title == item.title
    assert new_item.url == item.url
    assert new_item.link_page == item.link_page


def test_cell_is_visible():
    request = RequestFactory().get('/')
    page = Page.objects.create()
    cell = TextCell.objects.create(page=page, order=0)
    assert cell.is_visible(request) is True

    # invalid cell since just now
    validity_info = ValidityInfo.objects.create(content_object=cell)
    validity_info.invalid_reason_code = 'FOO'
    validity_info.invalid_since = now()
    validity_info.save()
    assert cell.is_visible(request) is True

    # invalid cell since two days
    validity_info.invalid_since = now() - datetime.timedelta(days=2)
    validity_info.save()
    assert cell.is_visible(request) is False


def test_cell_invalidity_marker():
    page = Page.objects.create()
    cell = TextCell.objects.create(page=page, order=0)
    cell.mark_as_invalid('foo_bar_reason')
    validity_info = ValidityInfo.objects.latest('pk')
    old_reason = validity_info.invalid_reason_code
    old_date = validity_info.invalid_since

    cell.mark_as_invalid('another_foo_bar_reason', force=False)
    validity_info.refresh_from_db()
    assert old_reason == validity_info.invalid_reason_code
    assert old_date == validity_info.invalid_since

    cell.mark_as_invalid('another_foo_bar_reason')
    validity_info.refresh_from_db()
    assert validity_info.invalid_reason_code == 'another_foo_bar_reason'
    assert old_date < validity_info.invalid_since

    cell.mark_as_valid()
    assert ValidityInfo.objects.exists() is False


def test_hourly():
    appconfig = apps.get_app_config('data')
    page = Page.objects.create(title='xxx', slug='test_current_forms_cell_render', template_name='standard')
    cell_classes = [c for c in appconfig.get_models() if c in get_cell_classes()]
    for klass in cell_classes:
        klass.objects.create(page=page, placeholder='content', order=0)
    for klass in cell_classes:
        if klass in [LinkCell, LinkListCell]:
            with mock.patch('combo.data.models.%s.check_validity' % klass.__name__) as check_validity:
                appconfig.hourly()
            assert check_validity.call_args_list == [mock.call()]
        else:
            assert hasattr(klass, 'check_validity') is False


def test_cell_assets(settings, app, admin_user):
    page = Page.objects.create(title='xxx', slug='test_cell_assets', template_name='standard')
    text_cell = TextCell.objects.create(page=page, order=0, slug='foo')
    list_cell = LinkListCell.objects.create(page=page, order=2, slug='bar')
    item = LinkCell.objects.create(
        page=page,
        placeholder=list_cell.link_placeholder,
        title='Example Site',
        link_page=page,
        order=1,
    )

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

    # only text cells are defined for assets
    settings.COMBO_CELL_ASSET_SLOTS = {'data_textcell': {'picture': {'prefix': 'Picture'}}}
    resp = app.get('/manage/assets/')
    assert 'Picture — %s' % text_cell.get_label_for_asset() in resp.text
    assert 'Picture — %s' % list_cell.get_label_for_asset() not in resp.text
    assert 'Picture — %s' % item.get_label_for_asset() not in resp.text

    # text and list link cells are defined for assets
    settings.COMBO_CELL_ASSET_SLOTS = {
        'data_textcell': {'picture': {'prefix': 'Picture'}},
        'data_linklistcell': {'picture': {'prefix': 'Picture'}},
        'data_linkcell': {'picture': {'prefix': 'Picture', 'suffix': 'test'}},
    }
    resp = app.get('/manage/assets/')
    assert 'Picture — %s' % text_cell.get_label_for_asset() in resp.text
    assert 'Picture — %s' % list_cell.get_label_for_asset() in resp.text
    # but items are excluded
    assert item.get_slug_for_asset() is None  # slug for asset is always None for items
    assert 'Picture — %s' % item.get_label_for_asset() not in resp.text

    # test slugs
    link_cell = LinkCell.objects.create(
        page=page,
        url='http://example.net/',
        order=1,
    )
    resp = app.get('/manage/assets/')
    assert link_cell.get_slug_for_asset() == ''
    assert 'Picture — %s' % link_cell.get_label_for_asset() not in resp.text

    link_cell.slug = 'foo'
    link_cell.save()
    resp = app.get('/manage/assets/')
    assert link_cell.get_slug_for_asset() == 'foo'
    assert 'Picture — %s (test)' % link_cell.get_label_for_asset() in resp.text

    link_cell.slug = ''
    link_cell.url = ''
    link_cell.link_page = page
    link_cell.save()
    resp = app.get('/manage/assets/')
    assert link_cell.get_slug_for_asset() == 'test_cell_assets'
    assert 'Picture — %s (test)' % link_cell.get_label_for_asset() in resp.text