Produits Entr'ouvert » w.c.s.

import datetime

import json

import os

import pytest

from django.utils.html import escape

from webtest import Upload

from wcs import fields

from wcs.formdef import FormDef

from wcs.qommon.http_request import HTTPRequest

from wcs.testdef import TestDef

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

from .test_all import create_superuser

@pytest.fixture

def pub():

    pub = create_temporary_pub()

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

    pub.set_app_dir(req)

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

    pub.write_cfg()

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

        pub.site_options.add_section('options')

    pub.site_options.set('options', 'enable-tests', 'true')

    with open(os.path.join(pub.app_dir, 'site-options.cfg'), 'w') as fd:

        pub.site_options.write(fd)

    FormDef.wipe()

    TestDef.do_table()

    TestDef.wipe()

    return pub

def teardown_module(module):

    clean_temporary_pub()

def test_tests_link_on_formdef_page(pub):

    formdef = FormDef()

    formdef.name = 'test title'

    formdef.store()

    create_superuser(pub)

    app = login(get_app(pub))

    resp = app.get(formdef.get_admin_url())

    assert 'Tests' in resp.text

    pub.site_options.set('options', 'enable-tests', 'false')

    with open(os.path.join(pub.app_dir, 'site-options.cfg'), 'w') as fd:

        pub.site_options.write(fd)

    resp = app.get(formdef.get_admin_url())

    assert 'Tests' not in resp.text

def test_tests_page(pub):

    user = create_superuser(pub)

    formdef = FormDef()

    formdef.name = 'test title'

    formdef.fields = [

        fields.PageField(

            id='0',

            label='1st page',

            type='page',

            post_conditions=[

                {'condition': {'type': 'django', 'value': 'form_var_text == "a"'}, 'error_message': 'Error'}

            ],

        ),

        fields.StringField(id='1', label='Text', varname='text'),

    ]

    formdef.store()

    app = login(get_app(pub))

    resp = app.get(formdef.get_admin_url())

    resp = resp.click('Tests')

    assert 'There are no tests yet.' in resp.text

    assert 'Run' not in resp.text

    assert 'Tests cannot be created because there are no completed forms.' in resp.text

    assert 'New' not in resp.text

    formdata = formdef.data_class()()

    formdata.just_created()

    formdata.receipt_time = datetime.datetime(2021, 1, 1, 0, 0).timetuple()

    formdata.data['1'] = 'a'

    formdata.user_id = user.id

    formdata.store()

    resp = app.get(formdef.get_admin_url())

    resp = resp.click('Tests')

    assert 'There are no tests yet.' in resp.text

    assert 'Run' not in resp.text

    assert 'New tests cannot be created' not in resp.text

    resp = resp.click('New')

    resp.form['name'] = 'First test'

    resp.form['formdata_id'].select(text='1-1 - admin')

    assert len(resp.form['formdata_id'].options) == 1

    resp = resp.form.submit().follow()

    assert 'First test' in resp.text

    assert 'no tests yet' not in resp.text

    resp = resp.click('Run')

    assert 'First test: Success!' in resp.text

    formdata = formdef.data_class()()

    formdata.just_created()

    formdata.receipt_time = datetime.datetime(2021, 1, 1, 0, 0).timetuple()

    formdata.data['1'] = 'b'

    formdata.store()

    resp = app.get('/backoffice/forms/1/tests/new')

    resp.form['name'] = 'Second test'

    resp.form['formdata_id'].select(text='1-2 - Unknown User')

    assert len(resp.form['formdata_id'].options) == 2

    resp = resp.form.submit().follow()

    assert 'First test' in resp.text

    assert 'Second test' in resp.text

    resp = resp.click('Run')

    assert 'First test: Success!' in resp.text

    assert 'Second test: Page 1 post condition was not met (form_var_text == "a").' in resp.text

def test_tests_page_formdefs_isolation(pub):

    formdef = FormDef()

    formdef.name = 'dummy'

    formdef.store()

    formdata = formdef.data_class()()

    formdata.just_created()

    formdata.store()

    other_formdef = FormDef()

    other_formdef.name = 'dummy2'

    other_formdef.store()

    formdata2 = other_formdef.data_class()()

    formdata2.just_created()

    formdata2.store()

    create_superuser(pub)

    app = login(get_app(pub))

    resp = app.get('/backoffice/forms/1/tests/new')

    assert len(resp.form['formdata_id'].options) == 1

    assert resp.form['formdata_id'].options[0][2] == '1-1 - Unknown User'

    resp = app.get('/backoffice/forms/2/tests/new')

    assert len(resp.form['formdata_id'].options) == 1

    assert resp.form['formdata_id'].options[0][2] == '2-1 - Unknown User'

def test_tests_import_export(pub):

    user = create_superuser(pub)

    formdef = FormDef()

    formdef.name = 'test title'

    formdef.fields = [fields.StringField(id='1', varname='test field', label='Test', type='string')]

    formdef.store()

    formdata = formdef.data_class()()

    formdata.just_created()

    formdata.receipt_time = datetime.datetime(2021, 1, 1, 0, 0).timetuple()

    formdata.data['1'] = 'a'

    formdata.user_id = user.id

    formdata.store()

    testdef = TestDef.create_from_formdata(formdef, formdata)

    testdef.name = 'First test'

    testdef.store()

    app = login(get_app(pub))

    resp = app.get('/backoffice/forms/1/tests/')

    export_resp = resp.click('First test')

    resp = resp.click('remove')

    resp = resp.form.submit().follow()

    assert 'First test' not in resp.text

    resp = resp.click('Import')

    resp.form['file'] = Upload('export.json', export_resp.body, 'application/json')

    resp = resp.form.submit().follow()

    assert TestDef.count() == 1

    assert 'First test' in resp.text

    assert escape('Test "First test" has been successfully imported.') in resp.text

    imported_testdef = TestDef.select()[0]

    assert imported_testdef.export_to_json() == testdef.export_to_json()

    export_json = json.loads(export_resp.body)

    export_json['data']['fields']['1'] = 'b'

    resp = resp.click('Import')

    resp.form['file'] = Upload('export.json', json.dumps(export_json).encode(), 'application/json')

    resp = resp.form.submit().follow()

    assert TestDef.count() == 1

    assert 'First test' in resp.text

    assert escape('Test "First test" has been successfully imported.') in resp.text

    imported_testdef = TestDef.get(imported_testdef.id)

    assert imported_testdef.data['fields']['1'] == 'b'

    resp = resp.click('Import')

    resp.form['file'] = Upload('export.json', b'invalid', 'application/json')

    resp = resp.form.submit()

    assert 'Expecting value: line 1 column 1' in resp.text

import datetime

import pytest

from wcs import fields

from wcs.formdef import FormDef

from wcs.qommon.http_request import HTTPRequest

from wcs.testdef import TestDef, TestError

from .utilities import clean_temporary_pub, create_temporary_pub

@pytest.fixture

def pub():

    pub = create_temporary_pub()

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

    pub.set_app_dir(req)

    pub.write_cfg()

    FormDef.wipe()

    return pub

def teardown_module(module):

    clean_temporary_pub()

def test_testdef_slug_generation(pub):

    TestDef.do_table()

    testdef = TestDef()

    testdef.name = 'test'

    testdef.object_type = 'formdef'

    testdef.object_id = '1'

    testdef.store()

    assert testdef.slug == 'test'

    testdef.slug = testdef.id = None

    testdef.store()

    assert testdef.slug == 'test-2'

    testdef.slug = testdef.id = None

    testdef.object_id = '2'

    testdef.store()

    assert testdef.slug == 'test'

def test_page_post_conditions(pub):

    formdef = FormDef()

    formdef.name = 'test title'

    formdef.fields = [

        fields.TitleField(id='0', label='Title', type='title'),

        fields.PageField(

            id='1',

            label='1st page',

            type='page',

            post_conditions=[

                {'condition': {'type': 'django', 'value': 'form_var_text == "a"'}, 'error_message': 'Error'}

            ],

        ),

        fields.StringField(id='2', label='Text', varname='text'),

        fields.PageField(

            id='3',

            label='2nd page',

            type='page',

            post_conditions=[

                {'condition': {'type': 'django', 'value': 'form_var_text2 == "a"'}, 'error_message': 'Error'}

            ],

        ),

        fields.StringField(id='4', label='Text', varname='text2'),

    ]

    formdef.store()

    formdata = formdef.data_class()()

    formdata.just_created()

    formdata.receipt_time = datetime.datetime(2021, 1, 1, 0, 0).timetuple()

    formdata.data['2'] = 'a'

    formdata.data['4'] = 'a'

    testdef = TestDef.create_from_formdata(formdef, formdata)

    testdef.run(formdef)

    formdata.data['4'] = 'b'

    testdef = TestDef.create_from_formdata(formdef, formdata)

    with pytest.raises(TestError) as excinfo:

        testdef.run(formdef)

    assert str(excinfo.value) == 'Page 2 post condition was not met (form_var_text2 == "a").'

    formdata.data['2'] = 'b'

    testdef = TestDef.create_from_formdata(formdef, formdata)

    with pytest.raises(TestError) as excinfo:

        testdef.run(formdef)

    assert str(excinfo.value) == 'Page 1 post condition was not met (form_var_text == "a").'

def test_page_post_condition_invalid(pub):

    formdef = FormDef()

    formdef.name = 'test title'

    formdef.fields = [

        fields.PageField(

            id='0',

            label='1st page',

            type='page',

            post_conditions=[{'condition': {'type': 'django', 'value': '{{}'}, 'error_message': 'Error'}],

        ),

    ]

    formdef.store()

    formdata = formdef.data_class()()

    formdata.just_created()

    formdata.receipt_time = datetime.datetime(2021, 1, 1, 0, 0).timetuple()

    testdef = TestDef.create_from_formdata(formdef, formdata)

    with pytest.raises(TestError) as excinfo:

        testdef.run(formdef)

    assert str(excinfo.value) == 'Failed to evaluate page 1 post condition.'

        'tests',

        from .tests import TestsDirectory

        self.tests = TestsDirectory(self.formdef)

        if get_publisher().has_site_option('enable-tests'):

            r += htmltext('<li><a href="tests/">%s</a></li>') % _('Tests')

# w.c.s. - web application for online forms

# Copyright (C) 2005-2022  Entr'ouvert

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, see <http://www.gnu.org/licenses/>.

import json

from quixote import get_response, get_session, redirect

from quixote.directory import Directory

from quixote.html import TemplateIO, htmltext

from wcs.qommon import _, template

from wcs.qommon.backoffice.menu import html_top

from wcs.qommon.errors import TraversalError

from wcs.qommon.form import FileWidget, Form, SingleSelectWidget, StringWidget

from wcs.qommon.storage import Equal, StrictNotEqual

from wcs.testdef import TestDef, TestError

class TestPage(Directory):

    _q_exports = ['delete', 'export']

    def __init__(self, component):

        try:

            self.testdef = TestDef.get(component)

        except KeyError:

            raise TraversalError()

    def delete(self):

        form = Form(enctype='multipart/form-data')

        form.add_submit('delete', _('Submit'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_widget('cancel').parse():

            return redirect('.')

        if not form.is_submitted() or form.has_errors():

            get_response().breadcrumb.append(('delete', _('Delete')))

            r = TemplateIO(html=True)

            r += htmltext('<h2>%s %s</h2>') % (_('Deleting Test:'), self.testdef)

            r += form.render()

            return r.getvalue()

        else:

            TestDef.remove_object(self.testdef.id)

            return redirect('..')

    def export(self):

        get_response().set_content_type('application/json')

        get_response().set_header(

            'content-disposition', 'attachment; filename=wcs_test_%s.json' % self.testdef.name

        )

        return json.dumps(self.testdef.export_to_json())

class TestsDirectory(Directory):

    _q_exports = ['', 'new', 'run', ('import', 'p_import')]

    section = 'tests'

    def __init__(self, objectdef):

        self.objectdef = objectdef

    def _q_traverse(self, path):

        get_response().breadcrumb.append(('tests', _('Tests')))

        html_top('tests', '%s - %s' % (self.objectdef.name, _('Tests')))

        return super()._q_traverse(path)

    def _q_lookup(self, component):

        return TestPage(component)

    def _q_index(self):

        context = {

            'testdefs': TestDef.select(

                [Equal('object_type', self.objectdef.get_table_name()), Equal('object_id', self.objectdef.id)]

            ),

            'formdata': self.objectdef.data_class().select([StrictNotEqual('status', 'draft')]),

        }

        return template.QommonTemplateResponse(templates=['wcs/backoffice/tests.html'], context=context)

    def new(self):

        form = Form(enctype='multipart/form-data')

        form.add(StringWidget, 'name', title=_('Name'), required=True, size=50)

        formadata_options = sorted(

            [

                (x.id, '%s - %s' % (x.id_display, x.user or _('Unknown User')))

                for x in self.objectdef.data_class().select([StrictNotEqual('status', 'draft')])

            ],

            key=lambda x: x[1],

        )

        form.add(SingleSelectWidget, 'formdata_id', title=_('Form'), required=True, options=formadata_options)

        form.add_submit('submit', _('Submit'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_widget('cancel').parse():

            return redirect('.')

        if not form.is_submitted() or form.has_errors():

            get_response().breadcrumb.append(('new', _('New')))

            r = TemplateIO(html=True)

            r += htmltext('<h2>%s</h2>') % _('New test')

            r += form.render()

            return r.getvalue()

        else:

            formdata_id = form.get_widget('formdata_id').parse()

            formdata = self.objectdef.data_class().get(formdata_id)

            testdef = TestDef.create_from_formdata(self.objectdef, formdata)

            testdef.name = form.get_widget('name').parse()

            testdef.store()

        return redirect('.')

    def run(self):

        get_response().breadcrumb.append(('run', _('Run tests')))

        testdef = TestDef.select(

            [Equal('object_type', self.objectdef.get_table_name()), Equal('object_id', self.objectdef.id)]

        )

        for test in testdef:

            try:

                test.run(self.objectdef)

            except TestError as e:

                test.error = e

        return template.QommonTemplateResponse(

            templates=['wcs/backoffice/test_results.html'], context={'tests': testdef}

        )

    def p_import(self):

        form = Form(enctype='multipart/form-data')

        form.add(FileWidget, 'file', title=_('File'), required=True)

        form.add_submit('submit', _('Import Test'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_submit() == 'cancel':

            return redirect('.')

        if form.is_submitted() and not form.has_errors():

            try:

                return self.import_submit(form)

            except ValueError:

                pass

        get_response().breadcrumb.append(('import', _('Import')))

        r = TemplateIO(html=True)

        r += htmltext('<h2>%s</h2>') % _('Import Test')

        r += htmltext('<p>%s</p>') % _(

            'You can add a new test or update an existing one by importing a JSON file.'

        )

        r += form.render()

        return r.getvalue()

    def import_submit(self, form):

        fp = form.get_widget('file').parse().fp

        try:

            testdef = TestDef.import_from_json(json.loads(fp.read()))

        except Exception as e:

            form.set_error('file', str(e))

            raise ValueError()

        get_session().message = ('info', _('Test "%s" has been successfully imported.') % testdef.name)

        return redirect('.')

    @staticmethod

    def evaluate_condition(dict_vars, formdef, condition):

{% extends "wcs/backoffice/base.html" %}

{% load i18n %}

{% block appbar-title %}{% trans "Tests results" %}{% endblock %}

{% block content %}

  <div class="section">

    <ul>

      {% for test in tests %}

        <li>{{ test }}{% trans ":" %} {% firstof test.error _("Success!") %}</li>

      {% endfor %}

    </ul>

  </div>

{% endblock %}

{% extends "wcs/backoffice/base.html" %}

{% load i18n %}

{% block appbar-title %}{% trans "Tests" %}{% endblock %}

{% block appbar-actions %}

  <a href="import" rel="popup">{% trans "Import" %}</a>

  {% if testdefs %}

    <a href="run">{% trans "Run tests" %}</a>

  {% endif %}

  {% if formdata %}

    <a href="new" rel="popup">{% trans "New" %}</a>

  {% endif %}

{% endblock %}

{% block content %}

  <div class="section">

    <h3>{% trans "Test form data" %}</h3>

    {% if not formdata %}

      <div class="infonotice">

        <p>{% trans "Tests cannot be created because there are no completed forms." %}</p>

      </div>

    {% endif %}

    {% if testdefs %}

      <ul class="objects-list single-links">

        {% for test in testdefs %}

          <li>

            <a download href="{{ test.id }}/export">{{ test }}</a>

            <a rel="popup" class="delete" href="{{ test.id }}/delete">{% trans "remove" %}</a>

          </li>

        {% endfor %}

      </ul>

    {% else %}

      <div><p>{% trans "There are no tests yet." %}<p></div>

    {% endif %}

  </div>

{% endblock %}

from quixote import get_publisher

from .qommon import _, misc

from .qommon.storage import Equal

class TestError(Exception):

    pass

    def __str__(self):

        return self.name

    def store(self, *args, comment=None, snapshot_store_user=True, **kwargs):

        if not self.slug:

            existing_slugs = {

                x.slug

                for x in self.select(

                    [Equal('object_type', self.object_type), Equal('object_id', self.object_id)]

                )

            }

            base_slug = misc.simplify(self.name)

            self.slug = base_slug

            i = 2

            while self.slug in existing_slugs:

                self.slug = '%s-%s' % (base_slug, i)

                i += 1

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

    @classmethod

    def create_from_formdata(cls, formdef, formdata):

        testdef = cls()

        testdef.object_type = formdef.get_table_name()

        testdef.object_id = formdef.id

        testdef.data = {

            'fields': formdata.data,

            'user': formdata.user.get_json_export_dict() if formdata.user else None,

        }

        return testdef

    def run(self, objectdef):

        formdata = objectdef.data_class()()

        if self.data['user']:

            formdata.set_user_from_json(self.data['user'])

        get_publisher().substitutions.reset()

        get_publisher().substitutions.feed(get_publisher())

        get_publisher().substitutions.feed(objectdef)

        get_publisher().substitutions.feed(formdata)

        page_no = 0

        page_post_conditions = []

        for field in objectdef.fields:

            if field.type == 'page':

                if page_post_conditions:

                    self.evaluate_page_conditions(page_no, formdata, objectdef, page_post_conditions)

                page_post_conditions = field.post_conditions or []

                page_no += 1

                continue

            if field.type in ('subtitle', 'title', 'comment', 'computed'):

                continue

            formdata.data[field.id] = self.data['fields'].get(field.id)

            get_publisher().substitutions.invalidate_cache()

        # evaluate last page post condition

        self.evaluate_page_conditions(page_no, formdata, objectdef, page_post_conditions)

    def evaluate_page_conditions(self, page_no, form_data, objectdef, conditions):

        from wcs.fields import Field

        for post_condition in conditions:

            condition = post_condition.get('condition', {})

            try:

                if not Field.evaluate_condition(form_data.data, objectdef, condition):

                    raise TestError(

                        _('Page %(no)s post condition was not met (%(condition)s).')

                        % {'no': page_no, 'condition': condition.get('value')}

                    )

            except RuntimeError:

                raise TestError(_('Failed to evaluate page %s post condition.') % page_no)

    def export_to_json(self):

        return {

            'name': self.name,

            'slug': self.slug,

            'object_type': self.object_type,

            'object_id': self.object_id,

            'data': self.data,

        }

    @classmethod

    def import_from_json(cls, data):

        testdefs = TestDef.select(

            [

                Equal('object_type', data['object_type']),

                Equal('object_id', data['object_id']),

                Equal('slug', data['slug']),

            ]

        )

        testdef = testdefs[0] if testdefs else TestDef()

        for k, v in data.items():

            setattr(testdef, k, v)

        testdef.store()

        return testdef