Produits Entr'ouvert » w.c.s.

from .tests import TestsDirectory

        'tests',

    tests_directory_class = TestsDirectory

        self.tests = self.tests_directory_class(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/>.

from quixote import get_response, 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.form import Form, SingleSelectWidget, StringWidget

from wcs.qommon.storage import Equal, StrictNotEqual

from wcs.testdata import TestData, TestError

class TestsDirectory(Directory):

    _q_exports = ['', 'new', 'run']

    section = 'tests'

    def __init__(self, objectdef):

        self.objectdef = objectdef

    def html_top(self, title):

        return html_top(self.section, title)

    def _q_index(self):

        self.html_top(self.objectdef.name)  # TODO improve

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

        context = {

            'testdata': TestData.select(

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

            )

        }

        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)

        form.add(

            SingleSelectWidget,

            'formdata_id',

            title=_('Form'),

            required=True,

            options=sorted(

                (x.id_display, '%s - %s' % (x.id_display, x.user))

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

            ),

        )

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

            self.html_top(title=_('New test'))

            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().select([Equal('id_display', formdata_id)])[0]

            testdata = TestData()

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

            testdata.object_type = self.objectdef.get_table_name()

            testdata.object_id = self.objectdef.id

            testdata.data = {'fields': formdata.data, 'user': formdata.user.get_json_export_dict()}

            testdata.store()

        return redirect('..')

    def run(self):

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

        testdata = TestData.select(

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

        )

        for test in testdata:

            try:

                test.run(self.objectdef)

            except TestError as e:

                test.error = e

        return template.QommonTemplateResponse(

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

        )

    @staticmethod

    def evaluate_condition(dict_vars, formdef, condition):

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

{% load i18n %}

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

{% block content %}

  <ul>

    {% for test in tests %}

      <li>

        {{ test }}{% trans ":" %}

        {% if not test.error %}

          {% trans "Success!" %}

        {% else %}

          {{ test.error }}

        {% endif %}

      </li>

    {% endfor %}

{% endblock %}

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

{% load i18n %}

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

{% block appbar-actions %}

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

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

{% endblock %}

{% block content %}

  <div class="section">

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

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

      {% for test in testdata %}

        <li><a href="#">{{ test }}</a></li>

      {% endfor %}

    </ul>

  </div>

{% endblock %}

from quixote import get_publisher

from .qommon import _, misc

class TestError(Exception):

    pass

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

        if not self.slug:

            existing_slugs = {x.slug for x in self.select(ignore_migration=True, ignore_errors=True)}

            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)

    def run(self, objectdef):

        formdata = objectdef.data_class()()

        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

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

                continue

            if not field.is_visible(formdata.data, objectdef):

                if field.id in self.data['fields']:

                    raise TestError(_('Tried to fill field "%s" but it is hidden.') % field.label)

                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)