def cso_testing(page=1):
if g.user.role.name == ROLE_HEAD_OF_INFORMATION_SECURITY:
is_tm_answered_on_questions = ApplicationData.is_tm_answered_on_questions()
chosen_processes = UserChoice.user_choice_processes_by_role_id(g.user.role_id).paginate(page, 1, False)
if is_tm_answered_on_questions.status:
current_process = chosen_processes.items[0]
questions_by_process = Question.chosen_questions(current_process.id).all()
else:
current_process = None
questions_by_process = []
form = TestForm(questions=questions_by_process)
is_cso_answered_on_questions = ApplicationData.is_cso_answered_on_questions()
if form.validate_on_submit():
if form.finish.data:
save_answers_to_db(form, g.user.role_id, current_process.id)
if not is_cso_answered_on_questions.status:
is_cso_answered_on_questions.status = bool(not is_cso_answered_on_questions.status)
is_cso_answered_on_questions.update()
make_statistic()
return redirect(url_for('cso'))
if form.next_page.data:
save_answers_to_db(form, g.user.role_id, current_process.id)
page = chosen_processes.next_num
return redirect(url_for('cso_testing', page=page))
html = render_template('roles/cso_testing.html', form=form,
current_process=current_process,
is_tm_answered_on_questions=is_tm_answered_on_questions,
is_cso_answered_on_questions=is_cso_answered_on_questions,
processes=chosen_processes,
investment_level=UserChoice.user_choice_chosen_investment_level())
return __make_tooltips(html)
else:
return u'Вы не можете получить доступ к этой странице'
def test_multiwidget_field(self):
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{% crispy form %}
""")
test_form = TestForm()
test_form.helper = FormHelper()
test_form.helper.layout = Layout(
MultiWidgetField('datetime_field',
attrs=({
'rel': 'test_dateinput'
}, {
'rel': 'test_timeinput',
'style': 'width: 30px;',
'type': "hidden"
})))
c = Context({'form': test_form})
html = template.render(c)
self.assertEqual(html.count('class="dateinput"'), 1)
self.assertEqual(html.count('rel="test_dateinput"'), 1)
self.assertEqual(html.count('rel="test_timeinput"'), 1)
self.assertEqual(html.count('style="width: 30px;"'), 1)
self.assertEqual(html.count('type="hidden"'), 1)
def test_multiwidget_field(self):
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{% crispy form %}
""")
test_form = TestForm()
test_form.helper = FormHelper()
test_form.helper.layout = Layout(
MultiWidgetField(
'datetime_field',
attrs=(
{'rel': 'test_dateinput'},
{'rel': 'test_timeinput', 'style': 'width: 30px;', 'type': "hidden"}
)
)
)
c = Context({'form': test_form})
html = template.render(c)
self.assertEqual(html.count('class="dateinput"'), 1)
self.assertEqual(html.count('rel="test_dateinput"'), 1)
self.assertEqual(html.count('rel="test_timeinput"'), 1)
self.assertEqual(html.count('style="width: 30px;"'), 1)
self.assertEqual(html.count('type="hidden"'), 1)
def test_error_and_help_inline(self):
form = TestForm({'email': 'invalidemail'})
form.helper = FormHelper()
form.helper.error_text_inline = False
form.helper.help_text_inline = True
form.helper.layout = Layout('email')
form.is_valid()
html = render_crispy_form(form)
# Check that help goes before error, otherwise CSS won't work
if settings.CRISPY_TEMPLATE_PACK == 'bootstrap':
help_position = html.find(
'<span id="hint_id_email" class="help-inline">')
error_position = html.find(
'<p id="error_1_id_email" class="help-block">')
self.assertTrue(help_position < error_position)
# Viceversa
form = TestForm({'email': 'invalidemail'})
form.helper = FormHelper()
form.helper.error_text_inline = True
form.helper.help_text_inline = False
form.helper.layout = Layout('email')
form.is_valid()
html = render_crispy_form(form)
# Check that error goes before help, otherwise CSS won't work
if settings.CRISPY_TEMPLATE_PACK == 'bootstrap':
error_position = html.find(
'<span id="error_1_id_email" class="help-inline">')
help_position = html.find(
'<p id="hint_id_email" class="help-block">')
self.assertTrue(error_position < help_position)
def test_form_show_errors(self):
form = TestForm(
{
"email": "invalidemail",
"first_name": "first_name_too_long",
"last_name": "last_name_too_long",
"password1": "yes",
"password2": "yes",
}
)
form.helper = FormHelper()
form.helper.layout = Layout(
AppendedText("email", "whatever"),
PrependedText("first_name", "blabla"),
AppendedPrependedText("last_name", "foo", "bar"),
MultiField("legend", "password1", "password2"),
)
form.is_valid()
form.helper.form_show_errors = True
html = render_crispy_form(form)
self.assertEqual(html.count("error"), 6)
form.helper.form_show_errors = False
html = render_crispy_form(form)
self.assertEqual(html.count("error"), 0)
def test_appended_prepended_text(self):
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{% crispy test_form %}
""")
test_form = TestForm()
test_form.helper = FormHelper()
test_form.helper.layout = Layout(
AppendedPrependedText('email', '@', 'gmail.com'),
AppendedText('password1', '#'),
PrependedText('password2', '$'),
)
c = Context({
'test_form': test_form,
})
html = template.render(c)
# Check form parameters
self.assertEqual(html.count('<span class="add-on ">@</span>'), 1)
self.assertEqual(html.count('<span class="add-on ">gmail.com</span>'),
1)
self.assertEqual(html.count('<span class="add-on ">#</span>'), 1)
self.assertEqual(html.count('<span class="add-on ">$</span>'), 1)
def test_getitem_by_field_name(self):
form = TestForm()
form.helper = FormHelper(form)
layout = Layout(Div("email"), "password1")
form.helper.layout = layout
form.helper["email"].wrap(Field, css_class="hero")
self.assertTrue(isinstance(layout.fields[0].fields[0], Field))
def test_form_show_errors_non_field_errors(self):
form = TestForm({"password1": "wargame", "password2": "god"})
form.helper = FormHelper()
form.helper.form_show_errors = True
form.is_valid()
template = get_template_from_string(
u"""
{% load crispy_forms_tags %}
{% crispy testForm %}
"""
)
# First we render with errors
c = Context({"testForm": form})
html = template.render(c)
# Ensure those errors were rendered
self.assertTrue("<li>Passwords dont match</li>" in html)
self.assertTrue(unicode(_("This field is required.")) in html)
self.assertTrue("error" in html)
# Now we render without errors
form.helper.form_show_errors = False
c = Context({"testForm": form})
html = template.render(c)
# Ensure errors were not rendered
self.assertFalse("<li>Passwords dont match</li>" in html)
self.assertFalse(unicode(_("This field is required.")) in html)
self.assertFalse("error" in html)
def new_test():
form = TestForm()
if form.validate_on_submit():
test = Test(
test_name=form.test_name.data,
num_mc=form.num_mc.data,
mc_answers=int(form.mc_answers.data),
num_or=form.num_or.data,
#or_points = int(form.or_points.data),
num_students=form.num_students.data,
#test_data = defaultGrid(form.num_mc.data, int(form.mc_answers.data), form.num_or.data, form.or_points.data,form.num_students.data),
mc_data=mcDetails(form.num_mc.data, int(form.mc_answers.data)),
or_data=orDetails(form.num_mc.data, form.num_or.data),
student_data=studentDetails(form.num_students.data),
added_by=session['email'])
try:
test.put()
test_id = test.key.id()
test = Test.get_by_id(test_id)
mc_data = json.dumps(test.mc_data)
or_data = json.dumps(test.or_data)
student_data = json.dumps(test.student_data)
flash(u'Test %s successfully saved.' % test_id, 'success')
return render_template('test_details.html',
test=Test.get_by_id(test_id),
test_id=test_id,
mc_data=mc_data,
or_data=or_data,
student_data=student_data)
except CapabilityDisabledError:
flash(u'App Engine Datastore is currently in read-only mode.',
'info')
return redirect(url_for('list_tests'))
return redirect(url_for('list_tests'))
def tm(page=1):
if g.user.role.name == ROLE_HEAD_OF_TACTICAL_LEVEL:
is_om_answered_on_questions = ApplicationData.is_om_answered_on_questions()
try:
chosen_processes = UserChoice.user_choice_processes_by_role_id(g.user.role_id).paginate(page, 1, False)
except NoResultFound:
chosen_processes = []
if is_om_answered_on_questions.status:
current_process = chosen_processes.items[0]
questions_by_process = Question.chosen_questions(current_process.id).all()
else:
current_process = None
questions_by_process = []
form = TestForm(questions=questions_by_process)
is_tm_answered_on_questions = ApplicationData.is_tm_answered_on_questions()
if form.validate_on_submit():
if form.finish.data:
page = chosen_processes.pages
save_answers_to_db(form, g.user.role_id, current_process.id)
if not is_tm_answered_on_questions.status:
is_tm_answered_on_questions.status = bool(not is_tm_answered_on_questions.status)
is_tm_answered_on_questions.update()
if form.next_page.data:
save_answers_to_db(form, g.user.role_id, current_process.id)
page = chosen_processes.next_num
return redirect(url_for('tm', page=page))
html = render_template('roles/tm.html', form=form,
current_process=current_process,
is_om_answered_on_questions=is_om_answered_on_questions,
is_tm_answered_on_questions=is_tm_answered_on_questions,
processes=chosen_processes,
investment_level=UserChoice.user_choice_chosen_investment_level())
return __make_tooltips(html)
else:
return u'Вы не можете получить доступ к этой странице'
def test_multiwidget_field(self):
template = get_template_from_string(
u"""
{% load crispy_forms_tags %}
{% crispy form %}
"""
)
test_form = TestForm()
test_form.helper = FormHelper()
test_form.helper.layout = Layout(
MultiWidgetField(
"datetime_field",
attrs=({"rel": "test_dateinput"}, {"rel": "test_timeinput", "style": "width: 30px;", "type": "hidden"}),
)
)
c = Context({"form": test_form})
html = template.render(c)
self.assertEqual(html.count('class="dateinput"'), 1)
self.assertEqual(html.count('rel="test_dateinput"'), 1)
self.assertEqual(html.count('rel="test_timeinput"'), 1)
self.assertEqual(html.count('style="width: 30px;"'), 1)
self.assertEqual(html.count('type="hidden"'), 1)
def test_field_with_buttons(self):
form = TestForm()
form.helper = FormHelper()
form.helper.layout = Layout(
FieldWithButtons(
Field("password1", css_class="span4"),
StrictButton("Go!", css_id="go-button"),
StrictButton("No!", css_class="extra"),
StrictButton("Test", type="submit", name="whatever", value="something"),
css_class="extra",
autocomplete="off",
)
)
html = render_crispy_form(form)
self.assertEqual(html.count('class="control-group extra"'), 1)
self.assertEqual(html.count('autocomplete="off"'), 1)
self.assertEqual(html.count('class="input-append"'), 1)
self.assertEqual(html.count('class="span4'), 1)
self.assertEqual(html.count('id="go-button"'), 1)
self.assertEqual(html.count("Go!"), 1)
self.assertEqual(html.count("No!"), 1)
self.assertEqual(html.count('class="btn"'), 2)
self.assertEqual(html.count('class="btn extra"'), 1)
self.assertEqual(html.count('type="submit"'), 1)
self.assertEqual(html.count('name="whatever"'), 1)
self.assertEqual(html.count('value="something"'), 1)
if settings.CRISPY_TEMPLATE_PACK == "bootstrap":
# Make sure white spaces between buttons are there in bootstrap
self.assertEqual(len(re.findall(r"</button> <", html)), 3)
def test_form_show_errors_non_field_errors(self):
form = TestForm({'password1': 'wargame', 'password2': 'god'})
form.helper = FormHelper()
form.helper.form_show_errors = True
form.is_valid()
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{% crispy testForm %}
""")
# First we render with errors
c = Context({'testForm': form})
html = template.render(c)
# Ensure those errors were rendered
self.assertTrue('<li>Passwords dont match</li>' in html)
self.assertTrue(unicode(_('This field is required.')) in html)
self.assertTrue('error' in html)
# Now we render without errors
form.helper.form_show_errors = False
c = Context({'testForm': form})
html = template.render(c)
# Ensure errors were not rendered
self.assertFalse('<li>Passwords dont match</li>' in html)
self.assertFalse(unicode(_('This field is required.')) in html)
self.assertFalse('error' in html)
def test_form_show_errors_non_field_errors(self):
form = TestForm({'password1': 'wargame', 'password2': 'god'})
form.helper = FormHelper()
form.helper.form_show_errors = True
form.is_valid()
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{% crispy testForm %}
""")
# First we render with errors
c = Context({'testForm': form})
html = template.render(c)
# Ensure those errors were rendered
self.assertTrue('<li>Passwords dont match</li>' in html)
self.assertTrue(unicode(_('This field is required.')) in html)
self.assertTrue('error' in html)
# Now we render without errors
form.helper.form_show_errors = False
c = Context({'testForm': form})
html = template.render(c)
# Ensure errors were not rendered
self.assertFalse('<li>Passwords dont match</li>' in html)
self.assertFalse(unicode(_('This field is required.')) in html)
self.assertFalse('error' in html)
def home():
form = TestForm()
if form.validate_on_submit():
name = form.name.data
return render_template("home.html", form=form, name=name)
return render_template("home.html", form=form, logout=users.create_logout_url(request.url))
def new_test():
form = TestForm()
if form.validate_on_submit():
test = Test(
test_name=form.test_name.data,
num_mc=form.num_mc.data,
mc_answers = int(form.mc_answers.data),
num_or=form.num_or.data,
#or_points = int(form.or_points.data),
num_students=form.num_students.data,
#test_data = defaultGrid(form.num_mc.data, int(form.mc_answers.data), form.num_or.data, form.or_points.data,form.num_students.data),
mc_data = mcDetails(form.num_mc.data, int(form.mc_answers.data)),
or_data = orDetails(form.num_mc.data,form.num_or.data),
student_data = studentDetails(form.num_students.data),
added_by=session['email']
)
try:
test.put()
test_id = test.key.id()
test = Test.get_by_id(test_id)
mc_data = json.dumps(test.mc_data)
or_data = json.dumps(test.or_data)
student_data = json.dumps(test.student_data)
flash(u'Test %s successfully saved.' % test_id, 'success')
return render_template('test_details.html', test = Test.get_by_id(test_id), test_id = test_id, mc_data = mc_data, or_data = or_data, student_data = student_data)
except CapabilityDisabledError:
flash(u'App Engine Datastore is currently in read-only mode.', 'info')
return redirect(url_for('list_tests'))
return redirect(url_for('list_tests'))
def cio(page=1):
"""
Отображение страницы для CIO
:param page: номер страницы (int)
:return: html
"""
# Проверяем полномочия пользователя (пользователь может просматривать страницы только по своему уровню доступа)
if g.user.role.name == ROLE_HEAD_OF_BASE_LEVEL:
# Получаем информацию о состоянии системы
is_cso_choose_processes = ApplicationData.is_cso_choose_processes()
# Получаем процессы, по которым должен пользователь пройти тестирование
# метод paginate(page, count, error_out) возвращает список объектов в количестве count на страницу page
# тем самым добиваемся того, что тестирование по 1 процессу является 1 страница
try:
chosen_processes = UserChoice.user_choice_processes_by_role_id(g.user.role_id).paginate(page, 1, False)
except NoResultFound:
chosen_processes = []
if is_cso_choose_processes.status:
# Определяем текущий процесс и список вопросов, которые нужно будет отрисовать на форме
current_process = chosen_processes.items[0]
questions_by_process = Question.chosen_questions(current_process.id).all()
else:
# Эта ветвь необходима для корректного завершения функции (например, когда тестирование не началось,
# а CSO прошёл аутентификацию
current_process = None
questions_by_process = []
# Создаём форму, в которую будут поступать ответы пользователя
form = TestForm(questions=questions_by_process)
is_cio_answered_on_questions = ApplicationData.is_cio_answered_on_questions()
# Форма прошла валидацию и отправлена?
if form.validate_on_submit():
# Тестирование завершено?
if form.finish.data:
page = chosen_processes.pages
# Сохраняем ответы в базу данных
save_answers_to_db(form, g.user.role_id, current_process.id)
if not is_cio_answered_on_questions.status:
# Изменяем параметр пройденности тестирования пользователя cio на обратное (False -> True)
is_cio_answered_on_questions.status = bool(not is_cio_answered_on_questions.status)
# Сохраняем параметр в базе данных
is_cio_answered_on_questions.update()
# Если пользователю предстоит проходить тестирование по нескольким процессам,
# и есть ещё процессы, на вопросы которых он не ответил,
# то сохраняем ответы со страницы и изменяем номер страницы на 1
if form.next_page.data:
save_answers_to_db(form, g.user.role_id, current_process.id)
page = chosen_processes.next_num
# Перенаправление пользователя на новый номер страницы
return redirect(url_for('cio', page=page))
# Отрисовка страницы
html = render_template('roles/cio.html', form=form,
current_process=current_process,
is_cso_choose_processes=is_cso_choose_processes,
is_cio_answered_on_questions=is_cio_answered_on_questions,
processes=chosen_processes,
investment_level=UserChoice.user_choice_chosen_investment_level())
return __make_tooltips(html)
else:
return u'Вы не можете получить доступ к этой странице'
def test_exclude_by_widget(self):
form = TestForm()
form.helper = FormHelper(form)
form.helper.layout = self.advanced_layout
self.assertEqual(
form.helper.exclude_by_widget(forms.PasswordInput).slice,
[[[0, 0, 0, 0], "email"], [[0, 3, 0], "first_name"], [[1], "last_name"]],
)
def test_filter_by_widget(self):
form = TestForm()
form.helper = FormHelper(form)
form.helper.layout = self.advanced_layout
self.assertEqual(form.helper.filter_by_widget(forms.PasswordInput).slice, [
[[0, 1, 0, 0], 'password1'],
[[0, 4, 0], 'password2'],
])
def test_attrs(self):
form = TestForm()
form.helper = FormHelper()
form.helper.attrs = {'id': 'TestIdForm', 'autocomplete': "off"}
html = render_crispy_form(form)
self.assertTrue('autocomplete="off"' in html)
self.assertTrue('id="TestIdForm"' in html)
def test_attrs(self):
form = TestForm()
form.helper = FormHelper()
form.helper.attrs = {'id': 'TestIdForm', 'autocomplete': "off"}
html = render_crispy_form(form)
self.assertTrue('autocomplete="off"' in html)
self.assertTrue('id="TestIdForm"' in html)
def test_filter_by_widget(self):
form = TestForm()
form.helper = FormHelper(form)
layout = Layout(Div(Div(Div('email')), Div('password1'), 'password2'))
form.helper.layout = layout
form.helper.filter_by_widget(forms.PasswordInput).wrap(
Field, css_class='hero')
self.assertTrue(isinstance(layout.fields[0].fields[2], Field))
def test_filter_by_widget(self):
form = TestForm()
form.helper = FormHelper(form)
form.helper.layout = self.advanced_layout
self.assertEqual(form.helper.filter_by_widget(forms.PasswordInput).slice, [
[[0, 1, 0, 0], 'password1'],
[[0, 4, 0], 'password2'],
])
def test_exclude_by_widget(self):
form = TestForm()
form.helper = FormHelper(form)
form.helper.layout = self.advanced_layout
self.assertEqual(form.helper.exclude_by_widget(forms.PasswordInput).slice, [
[[0, 0, 0, 0], 'email'],
[[0, 3, 0], 'first_name'],
[[1], 'last_name'],
])
def test(user_id, step, reps=5):
form = TestForm()
test_image_urls = get_gesture_sequence(reps)
data = form.data.data
gesture = form.image.data.split('/')[-1].replace(
'_', ' ').split('.')[0].strip()
# Handle index out of range error
if step >= len(test_image_urls):
return redirect(
url_for('.test', user_id=user_id, step=len(test_image_urls) - 1))
tests_per_rep = int(len(test_image_urls) / reps)
rep = math.ceil((step + 1) / tests_per_rep)
# remove data with matching id, cal_id && gesture from database
db.clear_existing_data({
'subject_id': user_id,
'gesture': gesture,
'repetition': rep
})
if form.validate_on_submit():
rows = []
# insert data into database
for count, item in enumerate(data):
reading, timestamp = item
timestamp = time.strftime(
"%H:%M:%S.{}".format(str(timestamp).split('.')[-1]),
time.localtime(timestamp))
rows.append({
'subject_id': user_id,
'gesture': gesture,
'repetition': rep,
'reading_count': count,
'readings': reading,
'timestamp': timestamp
})
try:
db.insert_data_repetition(rows)
except Exception as identifier:
sys.stderr.write(repr(identifier))
flash('Could not insert into database, please try again.',
'danger')
if step == len(test_image_urls) - 1:
return redirect(url_for('.done'))
else:
return redirect(url_for('.test', user_id=user_id, step=step + 1))
form.image.data = test_image_urls[step]
form.data.data = None
status_text = f'''Test: {int(step % tests_per_rep) + 1} / {tests_per_rep}
Rep: {rep} / {reps}'''
return render_template('test.html', form=form, status=status_text)
def test(request):
from forms import TestForm
if request.method == 'POST':
form = TestForm(request.POST)
if form.is_valid():
# code handle form and file data
return render_to_response('test.html', {'form': form, 'succ': True})
else:
form = TestForm()
return render_to_response('test.html', {'form': form})
def test_getitem_by_field_name(self):
form = TestForm()
form.helper = FormHelper(form)
layout = Layout(
Div('email'),
'password1',
)
form.helper.layout = layout
form.helper['email'].wrap(Field, css_class='hero')
self.assertTrue(isinstance(layout.fields[0].fields[0], Field))
def test_getitem_by_field_name(self):
form = TestForm()
form.helper = FormHelper(form)
layout = Layout(
Div('email'),
'password1',
)
form.helper.layout = layout
form.helper['email'].wrap(Field, css_class='hero')
self.assertTrue(isinstance(layout.fields[0].fields[0], Field))
def test_as_crispy_errors_form_without_non_field_errors(self):
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{{ form|as_crispy_errors }}
""")
form = TestForm({'password1': "god", 'password2': "god"})
form.is_valid()
c = Context({'form': form})
html = template.render(c)
self.assertFalse("errorMsg" in html or "alert" in html)
def test_as_crispy_errors_form_without_non_field_errors(self):
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{{ form|as_crispy_errors }}
""")
form = TestForm({'password1': "god", 'password2': "god"})
form.is_valid()
c = Context({'form': form})
html = template.render(c)
self.assertFalse("errorMsg" in html or "alert" in html)
def insert_into_test (request) :
if request.method == 'POST' :
form = TestForm(request.POST)
if form.is_valid() :
c = connection.cursor()
c.execute("insert into test VALUES(%s , %s)" , [form.cleaned_data['name'] , form.cleaned_data['cost']])
c.close()
else :
form = TestForm ()
return render(request, 'mani_tables/test_entry_form.html', {'form': form})
def test_html5_required(self):
form = TestForm()
form.helper = FormHelper()
form.helper.html5_required = True
html = render_crispy_form(form)
# 6 out of 7 fields are required and an extra one for the SplitDateTimeWidget makes 7.
self.assertEqual(html.count('required="required"'), 7)
form = TestForm()
form.helper = FormHelper()
form.helper.html5_required = False
html = render_crispy_form(form)
def test_exclude_by_widget_and_wrap(self):
form = TestForm()
form.helper = FormHelper(form)
form.helper.layout = self.advanced_layout
form.helper.exclude_by_widget(forms.PasswordInput).wrap(Field, css_class='hero')
# Check wrapped fields
self.assertTrue(isinstance(form.helper.layout[0][0][0][0], Field))
self.assertTrue(isinstance(form.helper.layout[0][3][0], Field))
self.assertTrue(isinstance(form.helper.layout[1], Field))
# Check others stay the same
self.assertTrue(isinstance(form.helper.layout[0][3][1], HTML))
self.assertTrue(isinstance(form.helper.layout[0][1][0][0], basestring))
self.assertTrue(isinstance(form.helper.layout[0][4][0], basestring))
def test_filter_by_widget(self):
form = TestForm()
form.helper = FormHelper(form)
layout = Layout(
Div(
Div(Div('email')),
Div('password1'),
'password2'
)
)
form.helper.layout = layout
form.helper.filter_by_widget(forms.PasswordInput).wrap(Field, css_class='hero')
self.assertTrue(isinstance(layout.fields[0].fields[2], Field))
class MainHandler(web.RequestHandler):
def initialize(self):
self.form = TestForm(meta={'locale': self.locale})
def get(self):
return self.render('page.html', form=self.form)
def post(self):
# just mock the form processing
# as it will always raise error
self.form.process(data={'username': '******'})
self.form.validate()
return self.render('page.html', form=self.form)
def test_exclude_by_widget_and_wrap(self):
form = TestForm()
form.helper = FormHelper(form)
form.helper.layout = self.advanced_layout
form.helper.exclude_by_widget(forms.PasswordInput).wrap(Field, css_class='hero')
# Check wrapped fields
self.assertTrue(isinstance(form.helper.layout[0][0][0][0], Field))
self.assertTrue(isinstance(form.helper.layout[0][3][0], Field))
self.assertTrue(isinstance(form.helper.layout[1], Field))
# Check others stay the same
self.assertTrue(isinstance(form.helper.layout[0][3][1], HTML))
self.assertTrue(isinstance(form.helper.layout[0][1][0][0], basestring))
self.assertTrue(isinstance(form.helper.layout[0][4][0], basestring))
def test_i18n(self):
template = get_template_from_string(
u"""
{% load crispy_forms_tags %}
{% crispy form form.helper %}
"""
)
form = TestForm()
form_helper = FormHelper()
form_helper.layout = Layout(HTML(_("i18n text")), Fieldset(_("i18n legend"), "first_name", "last_name"))
form.helper = form_helper
html = template.render(Context({"form": form}))
self.assertEqual(html.count("i18n legend"), 1)
def edit_test(test_id):
test = Test.get_by_id(test_id)
form = TestForm(obj=test)
if request.method == "POST":
if form.validate_on_submit():
test.test_name = form.data.get('test_name')
test.num_mc = form.data.get('num_mc')
test.num_or = form.data.get('num_or')
#test.num_students = json.dumps(form.data.get('num_students'))
test.num_students = form.data.get('num_students')
test.put()
flash(u'Test %s successfully saved.' % test_id, 'success')
return redirect(url_for('list_tests'))
return render_template('edit_test.html', test=test, form=form)
def edit_test(test_id):
test = Test.get_by_id(test_id)
form = TestForm(obj=test)
if request.method == "POST":
if form.validate_on_submit():
test.test_name = form.data.get('test_name')
test.num_mc = form.data.get('num_mc')
test.num_or = form.data.get('num_or')
#test.num_students = json.dumps(form.data.get('num_students'))
test.num_students = form.data.get('num_students')
test.put()
flash(u'Test %s successfully saved.' % test_id, 'success')
return redirect(url_for('list_tests'))
return render_template('edit_test.html', test=test, form=form)
def test_error_and_help_inline(self):
form = TestForm({'email': 'invalidemail'})
form.helper = FormHelper()
form.helper.error_text_inline = False
form.helper.help_text_inline = True
form.helper.layout = Layout('email')
form.is_valid()
html = render_crispy_form(form)
# Check that help goes before error, otherwise CSS won't work
if settings.CRISPY_TEMPLATE_PACK == 'bootstrap':
help_position = html.find('<span id="hint_id_email" class="help-inline">')
error_position = html.find('<p id="error_1_id_email" class="help-block">')
self.assertTrue(help_position < error_position)
# Viceversa
form = TestForm({'email': 'invalidemail'})
form.helper = FormHelper()
form.helper.error_text_inline = True
form.helper.help_text_inline = False
form.helper.layout = Layout('email')
form.is_valid()
html = render_crispy_form(form)
# Check that error goes before help, otherwise CSS won't work
if settings.CRISPY_TEMPLATE_PACK == 'bootstrap':
error_position = html.find('<span id="error_1_id_email" class="help-inline">')
help_position = html.find('<p id="hint_id_email" class="help-block">')
self.assertTrue(error_position < help_position)
def test_form(request):
layout = request.GET.get('layout')
if not layout:
layout = 'vertical'
if request.method == 'POST':
form = TestForm(request.POST)
form.is_valid()
else:
form = TestForm()
form.fields['title'].widget = BootstrapUneditableInput()
return render_to_response('form.html', RequestContext(request, {
'form': form,
'layout': layout,
}))
def test_error_text_inline(self):
form = TestForm({'email': 'invalidemail'})
form.helper = FormHelper()
layout = Layout(
AppendedText('first_name', 'wat'),
PrependedText('email', '@'),
AppendedPrependedText('last_name', '@', 'wat'),
)
form.helper.layout = layout
form.is_valid()
html = render_crispy_form(form)
matches = re.findall('<span id="error_\d_\w*" class="help-inline"',
html, re.MULTILINE)
self.assertEqual(len(matches), 3)
form = TestForm({'email': 'invalidemail'})
form.helper = FormHelper()
form.helper.layout = layout
form.helper.error_text_inline = False
html = render_crispy_form(form)
matches = re.findall('<p id="error_\d_\w*" class="help-block"', html,
re.MULTILINE)
self.assertEqual(len(matches), 3)
def demo_form_with_template(request):
layout = request.GET.get('layout')
if not layout:
layout = 'vertical'
if request.method == 'POST':
form = TestForm(request.POST)
form.is_valid()
else:
form = TestForm()
modelform = TestModelForm()
return render_to_response('form_using_template.html', RequestContext(request, {
'form': form,
'layout': layout,
}))
def tests():
'''
Testing options over the web GUI. Works only for hardcoded testsurvey at the moment.
'''
import requests
from forms import TestForm
form = TestForm()
flash("test")
if form.validate_on_submit():
print("generate summary button pressed") #debug
r = requests.get('http://localhost:5000/smmrs/create/testsurvey')
return render_template('tests.html', form=form, title='server tests')
def test_as_crispy_errors_form_with_non_field_errors(self):
template = get_template_from_string(
u"""
{% load crispy_forms_tags %}
{{ form|as_crispy_errors }}
"""
)
form = TestForm({"password1": "god", "password2": "wargame"})
form.is_valid()
c = Context({"form": form})
html = template.render(c)
self.assertTrue("errorMsg" in html or "alert" in html)
self.assertTrue("<li>Passwords dont match</li>" in html)
self.assertFalse("<h3>" in html)
def test_hidden_fields(self):
form = TestForm()
# All fields fake hidden
for field in form.fields:
form[field].field.widget.is_hidden = True
form.helper = FormHelper()
form.helper.layout = Layout(
AppendedText('password1', 'foo'),
PrependedText('password2', 'bar'),
AppendedPrependedText('email', 'bar'),
InlineCheckboxes('first_name'),
)
html = render_crispy_form(form)
self.assertEqual(html.count("<input"), 4)
def test_hidden_fields(self):
form = TestForm()
# All fields fake hidden
for field in form.fields:
form[field].field.widget.is_hidden = True
form.helper = FormHelper()
form.helper.layout = Layout(
AppendedText('password1', 'foo'),
PrependedText('password2', 'bar'),
AppendedPrependedText('email', 'bar'),
InlineCheckboxes('first_name'),
)
html = render_crispy_form(form)
self.assertEqual(html.count("<input"), 4)
def test_multifield_errors(self):
form = TestForm({"email": "invalidemail", "password1": "yes", "password2": "yes"})
form.helper = FormHelper()
form.helper.layout = Layout(MultiField("legend", "email"))
form.is_valid()
form.helper.form_show_errors = True
html = render_crispy_form(form)
self.assertEqual(html.count("error"), 3)
# Reset layout for avoiding side effects
form.helper.layout = Layout(MultiField("legend", "email"))
form.helper.form_show_errors = False
html = render_crispy_form(form)
self.assertEqual(html.count("error"), 0)
def test_change_layout_dynamically_delete_field(self):
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{% crispy form form_helper %}
""")
form = TestForm()
form_helper = FormHelper()
form_helper.add_layout(
Layout(
Fieldset(
u'Company Data',
'is_company',
'email',
'password1',
'password2',
css_id="multifield_info",
), Column(
'first_name',
'last_name',
css_id="column_name",
)))
# We remove email field on the go
# Layout needs to be adapted for the new form fields
del form.fields['email']
del form_helper.layout.fields[0].fields[1]
c = Context({'form': form, 'form_helper': form_helper})
html = template.render(c)
self.assertFalse('email' in html)
def test_inputs(self):
form_helper = FormHelper()
submit = Submit('my-submit', 'Submit', css_class="button white")
reset = Reset('my-reset', 'Reset')
hidden = Hidden('my-hidden', 'Hidden')
button = Button('my-button', 'Button')
form_helper.add_input(submit)
form_helper.add_input(reset)
form_helper.add_input(hidden)
form_helper.add_input(button)
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{% crispy form form_helper %}
""")
c = Context({'form': TestForm(), 'form_helper': form_helper})
html = template.render(c)
self.assertTrue('button white' in html)
self.assertTrue('submit submitButton' in html or 'btn' in html)
self.assertTrue('id="submit-id-my-submit"' in html)
self.assertTrue('reset resetButton' in html)
self.assertTrue('id="reset-id-my-reset"' in html)
self.assertTrue('name="my-hidden"' in html)
self.assertTrue('button' in html)
self.assertTrue('id="button-id-my-button"' in html)
def create_test(request, project_id):
""" Create a new Test.
"""
project = get_object_or_404(Project, pk=project_id)
form = TestForm(request.POST or None)
if form.is_valid():
new_test = form.save(commit=False) # returns unsaved instance
new_test.project = project
new_test.save() # real save to DB.
messages.add_message(request, messages.SUCCESS, 'The test has been successfully created.')
return redirect(details_project, project_id=project_id)
return render_to_response('form.html',
{'form' : form,
'project' : project},
context_instance=RequestContext(request))
def audit_model():
form = TestForm()
if request.method == 'POST':
labels = form.Labels.data
labels = labels.replace(' ', '')
labels = labels.split(',')
target = form.Target.data
zero_value = form.Zero_Value.data
print("Type of zero value is ", type(zero_value))
print(labels, target)
filename = secure_filename(form.file.data.filename)
form.file.data.save(os.path.join(app.config['UPLOAD_FOLDER'],
filename))
explanation_return = run_explanations(
os.path.join(app.config['UPLOAD_FOLDER'], filename), labels,
target, zero_value)
if explanation_return == "target column error":
flash("Target Column Error")
return redirect(request.url)
#return render_template('upload.html',title='Form Uploader',form=form)
elif explanation_return == "zero value error":
flash("Zero Value Error")
return redirect(request.url)
else:
return render_template('explanation.html')
return render_template('upload2.html', title='Form Uploader', form=form)
def personal_stats(request, stats_id):
key = request.GET.get('key', '')
try:
fg = FunctionalGroup.objects.get(abbreviation=key)
if fg.metric_type == FunctionalGroup.TESTING:
personal_stat = TestStats.objects.get(pk=stats_id)
form = TestForm(instance=personal_stat)
elif fg.metric_type == FunctionalGroup.DEVELOPMENT:
personal_stat = InnovationStats.objects.get(pk=stats_id)
form = InnovationForm(instance=personal_stat)
elif fg.metric_type == FunctionalGroup.REQUIREMENTS:
personal_stat = RequirementStats.objects.get(pk=stats_id)
form = RequirementForm(instance=personal_stat)
elif fg.metric_type == FunctionalGroup.LAB:
personal_stat = LabStats.objects.get(pk=stats_id)
form = LabForm(instance=personal_stat)
else:
raise ValueError("Fell through stat retrieval table")
except Exception as e:
print e
messages.error(
request,
'Failed to load selected scorecard. Please email [email protected] for assistance.'
)
return redirect('personals:personals')
context = RequestContext(request, {
'personal_stat': personal_stat,
'form': form
})
return render(request, 'personals/personal_stats.html', context)
def test_inputs(self):
form_helper = FormHelper()
submit = Submit('my-submit', 'Submit', css_class="button white")
reset = Reset('my-reset', 'Reset')
hidden = Hidden('my-hidden', 'Hidden')
button = Button('my-button', 'Button')
form_helper.add_input(submit)
form_helper.add_input(reset)
form_helper.add_input(hidden)
form_helper.add_input(button)
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{% crispy form form_helper %}
""")
c = Context({'form': TestForm(), 'form_helper': form_helper})
html = template.render(c)
self.assertTrue('button white' in html)
self.assertTrue('id="submit-id-my-submit"' in html)
self.assertTrue('id="reset-id-my-reset"' in html)
self.assertTrue('name="my-hidden"' in html)
self.assertTrue('id="button-id-my-button"' in html)
if settings.CRISPY_TEMPLATE_PACK == 'uni_form':
self.assertTrue('submit submitButton' in html)
self.assertTrue('reset resetButton' in html)
self.assertTrue('class="button"' in html)
else:
self.assertTrue('class="btn"' in html)
self.assertTrue('btn btn-primary' in html)
self.assertTrue('btn btn-inverse' in html)
self.assertEqual(html.count('/>‌'), 4)
def test_second_layout_multifield_column_buttonholder_submit_div(self):
form_helper = FormHelper()
form_helper.add_layout(
Layout(
MultiField("Some company data",
'is_company',
'email',
css_id="multifield_info",
title="multifield_title",
multifield_test="123"),
Column(
'first_name',
'last_name',
css_id="column_name",
css_class="columns",
),
ButtonHolder(
Submit('Save the world',
'{{ value_var }}',
css_class='button white',
data_id='test',
data_name='test'), Submit('store',
'Store results')),
Div('password1',
'password2',
css_id="custom-div",
css_class="customdivs",
test_markup="123")))
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{% crispy form form_helper %}
""")
c = Context({
'form': TestForm(),
'form_helper': form_helper,
'value_var': "Save"
})
html = template.render(c)
self.assertTrue('multiField' in html)
self.assertTrue('formColumn' in html)
self.assertTrue('id="multifield_info"' in html)
self.assertTrue('title="multifield_title"' in html)
self.assertTrue('multifield-test="123"' in html)
self.assertTrue('id="column_name"' in html)
self.assertTrue('class="formColumn columns"' in html)
self.assertTrue('class="buttonHolder">' in html)
self.assertTrue('input type="submit"' in html)
self.assertTrue('button white' in html)
self.assertTrue('data-id="test"' in html)
self.assertTrue('data-name="test"' in html)
self.assertTrue('name="save-the-world"' in html)
self.assertTrue('value="Save"' in html)
self.assertTrue('name="store"' in html)
self.assertTrue('value="Store results"' in html)
self.assertTrue('id="custom-div"' in html)
self.assertTrue('class="customdivs"' in html)
self.assertTrue('test-markup="123"' in html)
def personal_stats_edit(request, stats_id):
key = request.GET.get('key', '')
if request.method == 'POST':
if key in ['QA', 'TE']:
personal_stat = get_object_or_404(TestStats, pk=stats_id)
form = TestForm(request.POST, instance=personal_stat)
elif key == 'QI':
personal_stat = get_object_or_404(InnovationStats, pk=stats_id)
form = InnovationForm(request.POST, instance=personal_stat)
elif key == 'RE':
personal_stat = get_object_or_404(RequirementStats, pk=stats_id)
form = RequirementForm(request.POST, instance=personal_stat)
elif key == 'TL':
personal_stat = get_object_or_404(LabStats, pk=stats_id)
form = LabForm(request.POST, instance=personal_stat)
if form.is_valid():
personal_stat = form.save()
if not personal_stat.updated:
personal_stat.updated = True
personal_stat.save()
return redirect('personals:personals')
else:
messages.error(request, 'Correct errors in the form')
context = RequestContext(request, {
'personal_stat': personal_stat,
'form': form
})
return render(request, 'personals/personal_stats.html', context)
else:
return redirect('personals:personals')
def create_test(request, project_id):
""" Create a new Test.
"""
project = get_object_or_404(Project, pk=project_id)
form = TestForm(request.POST or None)
if form.is_valid():
new_test = form.save(commit=False) # returns unsaved instance
new_test.project = project
new_test.save() # real save to DB.
messages.add_message(request, messages.SUCCESS,
'The test has been successfully created.')
return redirect(details_project, project_id=project_id)
return render_to_response('form.html', {
'form': form,
'project': project
},
context_instance=RequestContext(request))
def test_i18n(self):
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{% crispy form form.helper %}
""")
form = TestForm()
form_helper = FormHelper()
form_helper.layout = Layout(
HTML(_("i18n text")),
Fieldset(
_("i18n legend"),
'first_name',
'last_name',
))
form.helper = form_helper
html = template.render(Context({'form': form}))
self.assertEqual(html.count('i18n legend'), 1)
def uploadFile():
form = TestForm()
if request.method == 'POST':
labels = form.Labels.data
target = form.Target.data
filename = secure_filename(form.file.data.filename)
form.file.data.save(os.path.join(app.config['UPLOAD_FOLDER'],
filename))
return redirect(url_for('uploaded_file', filename=filename))
return render_template('upload.html', title='Form Uploader', form=form)
def test_crispy_filter_with_form(self):
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{{ form|crispy }}
""")
c = Context({'form': TestForm()})
html = template.render(c)
self.assertTrue("<td>" not in html)
self.assertTrue("id_is_company" in html)
