Produits Entr'ouvert » w.c.s.

    return pub_fixture(sql_mode=True)

def teardown_module(module):

    clean_temporary_pub()

    carddata.remove_self()  # don't keep leftovers

def test_cards_in_use_delete(pub):

    CardDef.wipe()

    carddef = CardDef()

    return pub_fixture(sql_mode=True)

def teardown_module(module):

    clean_temporary_pub()

    )

def test_data_sources_users(pub):

    create_superuser(pub)

    NamedDataSource.wipe()

import io

import os

import re

import time

import xml.etree.ElementTree as ET

from unittest import mock

    return pub_fixture(sql_mode=True)

def teardown_module(module):

    clean_temporary_pub()

    _test_form_workflow_remapping(pub)

def test_form_submitter_roles(pub):

    create_superuser(pub)

    create_role(pub)

    assert 'Deletion is not possible' not in resp

def test_form_duplicate(pub):

    create_superuser(pub)

    create_role(pub)

    assert 'backoffice/management/form-title/' in resp

def test_form_overwrite(pub):

    create_superuser(pub)

    create_role(pub)

from ..utilities import clean_temporary_pub, create_temporary_pub, get_app, login

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from ..utilities import clean_temporary_pub, create_temporary_pub, get_app

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .utils import sign_uri

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .utils import sign_uri

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .utils import sign_uri

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .utils import sign_uri

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .utils import sign_uri

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

    assert resp.json['data'][0]['url'] == 'http://example.net/api/statistics/forms/count/'

def test_statistics_index_categories(pub):

    Category(name='Category A').store()

    Category(name='Category B').store()

from .utils import sign_uri

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .utils import sign_uri

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from ..utilities import clean_temporary_pub, create_temporary_pub, get_app, login

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .test_all import create_superuser, create_user

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .test_all import create_superuser

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .test_all import create_superuser, create_user

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .test_all import create_superuser

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .test_all import create_environment, create_superuser

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .test_all import create_user

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.cfg['identification'] = {'methods': ['password']}

from .test_all import create_environment, create_superuser, create_user

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .test_all import create_superuser, create_user

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .test_all import create_superuser

@pytest.fixture

def pub(request, emails):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.cfg['identification'] = {'methods': ['password']}

def pytest_generate_tests(metafunc):

    if 'pub' in metafunc.fixturenames:

def pub_fixture(**kwargs):

@pytest.fixture

def pub(request, emails):

@pytest.fixture

def pytest_generate_tests(metafunc):

    if 'pub' in metafunc.fixturenames:

@pytest.fixture

from .test_all import create_user

@pytest.fixture

def pub(request, emails):

    pub.cfg['identification'] = {'methods': ['password']}

    pub.cfg['language'] = {'language': 'en'}

    pub.write_cfg()

def pytest_generate_tests(metafunc):

    if 'pub' in metafunc.fixturenames:

@pytest.fixture

def pytest_generate_tests(metafunc):

    if 'pub' in metafunc.fixturenames:

@pytest.fixture

def pytest_generate_tests(metafunc):

    if 'pub' in metafunc.fixturenames:

@pytest.fixture

@pytest.fixture

def pub():

    pub.cfg['identification'] = {'methods': ['password']}

    pub.cfg['language'] = {'language': 'en'}

    pub.write_cfg()

from .utilities import clean_temporary_pub, create_temporary_pub

@pytest.fixture

def pub(request):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

    pub.cfg['language'] = {'language': 'en'}

    global pub

def teardown_module(module):

def test_xml_export(category_class):

    category_class.wipe()

    test = category_class()

    test.name = 'Test'

    test.description = 'Hello world'

    test.store()

    assert b'<name>Test</name>' in test.export_to_xml_string(include_id=True)

    assert b' id="1"' in test.export_to_xml_string(include_id=True)

def test_get_by_urlname(category_class):

    category_class.wipe()

    test = category_class()

    test.name = 'Test'

    test.description = 'Hello world'

    test.store()

    test2 = category_class.get_by_urlname('test')

    assert test.id == test2.id

def test_has_urlname(category_class):

    category_class.wipe()

    test = category_class()

    test.name = 'Test'

    test.description = 'Hello world'

    test.store()

    assert category_class.has_urlname('test')

    assert not category_class.has_urlname('foobar')

def test_remove_self(category_class):

    category_class.wipe()

    test = category_class()

    test.name = 'Test'

    test.description = 'Hello world'

    test.store()

    test.remove_self()

    with pytest.raises(KeyError):

    clean_temporary_pub()

@pytest.fixture

def two_pubs(request):

    pub.cfg['language'] = {'language': 'en'}

    pub.write_cfg()

    return pub

    def run_trigger(trigger, rows):

        formdef.data_class().wipe()

        formdata = formdef.data_class()()

        formdata.data = {'0': 'Alice', '1': 'alice@example.net'}

        formdata.status = 'wf-%s' % st1.id

        formdata.store()

        id1 = formdata.id

        formdata = formdef.data_class()()

        formdata.data = {'0': 'Bob', '1': 'bob@example.net'}

        formdata.status = 'wf-%s' % st1.id

        formdata.store()

from .utilities import clean_temporary_pub, create_temporary_pub

@pytest.fixture

def pub(request):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

def setup_module(module):

    cleanup()

    global pub

def setup_user_profile(pub):

        ],

    }

    pub.user_class.wipe()

    pub.write_cfg()

    app = get_app(pub)

def test_bool_stats():

    formdef = FormDef()

    formdef.url_name = 'title'

    formdef.fields = [fields.BoolField(id='1')]

    data_class = formdef.data_class()

    formdatas = []

    for value in (True, True, True, False):

from .utilities import clean_temporary_pub, create_temporary_pub

@pytest.fixture

def pub(request):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from .utilities import clean_temporary_pub, create_temporary_pub

@pytest.fixture

def pub(request):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

    pub.cfg['language'] = {'language': 'en'}

import sys

import tempfile

import urllib.parse

from unittest import mock

from quixote import cleanup

from wcs import fields, sql

from wcs.ctl.check_hobos import CmdCheckHobos

from wcs.publisher import WcsPublisher

from wcs.qommon import force_str

from .utilities import clean_temporary_pub, create_temporary_pub

}

    hobo_cmd = CmdCheckHobos()

    hobo_cmd.all_services = HOBO_JSON

    clean_temporary_pub()

    shutil.rmtree(alt_tempdir)

    service = [x for x in HOBO_JSON.get('services', []) if x.get('service-id') == 'wcs'][0]

    hobo_cmd.configure_site_options(service, pub)

    pub.load_site_options()

    assert pub.get_site_option('xxx', 'variables') is None

    service = [x for x in HOBO_JSON.get('services', []) if x.get('service-id') == 'wcs'][0]

    hobo_cmd.update_configuration(service, pub)

    assert pub.cfg['misc']['sitename'] == 'Test wcs'

    assert pub.cfg['sms']['sender'] == 'EO'

    pub.cfg['branding'] = {'theme': 'default'}

    service = [x for x in HOBO_JSON.get('services', []) if x.get('service-id') == 'wcs'][0]

    hobo_cmd.update_configuration(service, pub)

    )

    profile = HOBO_JSON.get('profile')

    # load in an empty site

            assert attribute_mapping[attribute_name] == field_id

    pub.cfg['idp'] = {}

    service = [x for x in HOBO_JSON.get('services', []) if x.get('service-id') == 'wcs'][0]

    # with real metadata

    hobo_cmd.configure_authentication_methods(service, pub)

    idp_keys = list(pub.cfg['idp'].keys())

    assert len(idp_keys) == 1

        hobo_cmd.all_services = HOBO_JSON

    cleanup()

    hobo_cmd = CmdCheckHobos()

    base_options = {}

    sub_options_class = collections.namedtuple('Options', ['ignore_timestamp', 'redeploy', 'extra'])

    assert os.path.exists(os.path.join(alt_tempdir, 'tenants', 'wcs.example.net'))

    # update

    cleanup()

    with open(os.path.join(alt_tempdir, 'tenants', 'wcs.example.net', 'config.pck'), 'rb') as fd:

        pub_cfg = pickle.load(fd)

    assert pub_cfg['language'] == {'language': 'fr'}

    cleanup()

    with open(os.path.join(alt_tempdir, 'hobo.json'), 'w') as fd:

        hobo_json = copy.deepcopy(HOBO_JSON)

        del hobo_json['services'][1]  # authentic

    )

    assert os.path.exists(os.path.join(alt_tempdir, 'tenants', 'wcs.example.net'))

    cleanup()

    pub = WcsPublisher.create_publisher(register_tld_names=False)

from .utilities import create_temporary_pub, get_app

@pytest.fixture

def pub(request):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

    yield pub, hobo_cmd

    clean_temporary_pub()

    cleanup_connection()

    for dbname in (WCS_DB_NAME, NEW_WCS_DB_NAME):

        cursor.execute('DROP DATABASE IF EXISTS %s' % dbname)

def user(request):

    pub.user_class.wipe()

    user = pub.user_class(name='user')

    user.email = 'test@example.net'

    get_request()._user = user

    return user

        for hostname in hostnames:

            if not os.path.exists(os.path.join(pub.APP_DIR, hostname)):

                os.mkdir(os.path.join(pub.APP_DIR, hostname))

        with mock.patch('wcs.qommon.management.commands.cron.cron_worker') as cron_worker:

            with mock.patch('wcs.qommon.publisher.QommonPublisher.get_tenants') as mock_tenants:

def test_clean_loggederrors_no_sql():

    # do nothing, no error

    pub.clean_loggederrors()

from .utilities import clean_temporary_pub, create_temporary_pub, get_app

@pytest.fixture

def pub(request):

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

from quixote import get_publisher

from wcs import sql

def indexhtml(user=None):

    return str(wcs.forms.root.RootDirectory()._q_index())

role_uuid2 = str(uuid.uuid4())

@pytest.fixture

def pub(request):

    if not pub.cfg:

        pub.cfg = {}

    pass

@pytest.fixture(scope='function')

def pub(request):

    def fin():

        shutil.rmtree(pub.APP_DIR)

    assert 'UPDATE' in sql_queries[1]

    c = io.BytesIO()

    with zipfile.ZipFile(c, 'w') as z:

        z.writestr(

from .utilities import create_temporary_pub

@pytest.fixture

def pub(request):

    return create_temporary_pub(sql_mode=True)

def test_migrate_to_sql(pub):

    get_publisher().token_class.wipe()

    assert get_publisher().token_class.count() == 0

    assert sql_token.expiration.year == now().year

    get_publisher().token_class.wipe()

    token = get_publisher().token_class()

    token.store()

        assert get_publisher().token_class().get(token.id)

    get_publisher().token_class.wipe()

    token = get_publisher().token_class()

    token.store()

from .utilities import clean_temporary_pub, create_temporary_pub

@pytest.fixture

def pub(request):

def teardown_module(module):

def pytest_generate_tests(metafunc):

    if 'pub' in metafunc.fixturenames:

@pytest.fixture

known_elements = KnownElements()

    if get_publisher():

        get_publisher().cleanup()

        cleanup()

        APP_DIR = known_elements.legacy_theme_app_dir

    elif lazy_mode and known_elements.lazy_app_dir:

        APP_DIR = known_elements.lazy_app_dir

        APP_DIR = known_elements.sql_app_dir

    elif not (legacy_theme_mode or lazy_mode or sql_mode) and known_elements.pickle_app_dir:

        APP_DIR = known_elements.pickle_app_dir

            known_elements.legacy_theme_app_dir = APP_DIR

        elif lazy_mode:

            known_elements.lazy_app_dir = APP_DIR

            known_elements.sql_app_dir = APP_DIR

        else:

            known_elements.pickle_app_dir = APP_DIR

    clean_temporary_pub()

def pub_fixture(**kwargs):

    pub = create_temporary_pub(**kwargs)

    pub.cfg['language'] = {'language': 'en'}

@pytest.fixture

def two_pubs(request):

@pytest.fixture

    FormDef.wipe()

    formdef = FormDef()

    formdef.url_name = 'foobar'

    formdef._workflow = workflow

    formdata = formdef.data_class()()

    formdata.just_created()

    FormDef.wipe()

    formdef = FormDef()

    formdef.url_name = 'foobar'

    formdef.fields = [

        FileField(id='1', label='File1', type='file', varname='file1'),

    FormDef.wipe()

    formdef = FormDef()

    formdef.url_name = 'foobar'

    formdef._workflow = workflow

    formdata = formdef.data_class()()

    formdata.status = 'wf-st1'

    ]

    block.store()

    formdef = FormDef()

    formdef.name = 'foo-export-details'

    formdef.fields = [

        FileField(id='9', label='File', type='file'),

        DateField(id='10', label='Date', type='date'),

        ItemField(id='11', label='Item', type='item', items=['foo', 'bar']),

        TableField(id='12', label='Table', type='table', columns=['a', 'b'], rows=['c', 'd']),

        PageField(id='13', label='Empty Page', type='page'),

        TitleField(id='14', label='Empty Title', type='title'),

        StringField(id='15', label='Empty String', type='string', varname='invisiblestr'),

        BlockField(id='16', label='Block Field', type='block:foobar'),

    ]

    formdef.store()

    formdef.data_class().wipe()

    # run, against no parent

    perform_items([update_action], formdata)

    card = carddef.data_class().get(carddata.id)

    # other parent

    formdata.submission_context = {

    formdata.store()

    perform_items([update_action], formdata)

    card = carddef.data_class().get(carddata.id)

    # appropriate parent

    formdata.submission_context = {

    # run, against no parent

    perform_items([update_action], formdata)

    card = carddef.data_class().get(carddata.id)

    # appropriate parent

    formdata.submission_context = {

    clean_temporary_pub()

@pytest.fixture

def pub(request):

    pub = create_temporary_pub()

@pytest.fixture

def two_pubs(request):

    pub.cfg['language'] = {'language': 'en'}

    pub.write_cfg()

    req = HTTPRequest(None, {'SERVER_NAME': 'example.net', 'SCRIPT_NAME': ''})

    assert carddef1.data_class().count() == 1

    assert carddef2.data_class().count() == 1

    assert carddata1.data['1'] == 'card1 foo'

    assert carddata2.data['1'] == 'card2 bar'

    assert carddata2.data['2'] == str(carddata1.id)

    assert carddef1.data_class().count() == 1

    assert carddef2.data_class().count() == 1

    assert carddata1.data['1'] == 'card1 fooo'

    assert carddata2.data['1'] == 'card2 barr'

    assert carddata2.data['2'] == str(carddata1.id)

    assert carddef1.data_class().count() == 1

    assert carddef2.data_class().count() == 1

    assert carddata1.data['1'] == 'card1 fooo'

    assert carddata2.data['1'] == 'card2 barr'

    assert carddata2.data['2'] == str(carddata1.id)

    assert carddef1.data_class().count() == 2

    assert carddef2.data_class().count() == 2

    assert carddata1.data['1'] == 'card1 fooo'

    assert carddata2.data['1'] == 'card2 barr'

    assert carddata2.data['2'] == str(carddata1.id)

    assert carddef1.data_class().count() == 1

    assert carddef2.data_class().count() == 1

    assert carddata1.data['1'] == 'card1 fooo'

    assert carddata2.data['1'] == 'card2 barr'

    assert carddata2.data['2'] == str(carddata1.id)

    assert carddef1.data_class().count() == 1

    assert carddef2.data_class().count() == 1

    assert carddata1.data['1'] == 'card1 fooo'

    assert carddata2.data['1'] == 'card2 barr'

    assert carddata2.data['2'] == str(carddata1.id)

    formdata.perform_workflow()

    data = carddef.data_class().select()[0]

def test_assign_carddata_with_linked_object(pub):

    assert carddef.data_class().count() == 1

    card_data = carddef.data_class().select()[0]

def test_assign_carddata_manual_targeting(two_pubs):

        # run workflow, verify that carddata is assign

        carddata.just_created()

        carddata.perform_workflow()

        assert carddata.status == 'wf-%s' % st2.id

    carddata.store()

    carddata.just_created()

    carddata.perform_workflow()

    carddata_reloaded = carddata.get(carddata.id)

    assert carddata_reloaded.status == 'wf-2'

def test_assign_carddata_user_association(two_pubs):

    clean_temporary_pub()

@pytest.fixture

def pub(request):

    pub = create_temporary_pub()

@pytest.fixture

def two_pubs(request):

    pub.cfg['language'] = {'language': 'en'}

    pub.write_cfg()

    req = HTTPRequest(None, {'SERVER_NAME': 'example.net', 'SCRIPT_NAME': ''})

    formdata.just_created()

    formdata.store()

    if not pub.site_options.has_section('variables'):

        pub.site_options.add_section('variables')

    pub.site_options.set('variables', 'portal_url', 'https://portal/')

        if not pub.cfg.get('postgresql'):

            return

        import psycopg2

        import psycopg2.errorcodes