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_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 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 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 demo_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_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 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 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 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_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 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 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_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_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_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 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 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 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)
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_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_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 testEdit(request, mode, id=0):
render = render_options(request)
if request.method == 'GET':
if mode == 'add':
form = TestForm()
elif mode == 'edit':
form = TestForm(instance=get_object_or_404(Test, id=id))
else:
get_object_or_404(Test, id=id).delete()
return HttpResponseRedirect('/tests/test/')
form.fields['subject'].queryset = request.user.subjects
form.fields['grades'].queryset = request.user.grades
del form.fields['share']
render['form'] = form
return render_to_response('test.html', render)
else:
if mode == 'add':
form = TestForm(request.POST)
if form.is_valid():
test = form.save(commit=False)
test.teacher = request.user
test.save()
form.save_m2m()
return HttpResponseRedirect('/tests/test/')
else:
form.fields['subject'].queryset = request.user.subjects
form.fields['grades'].queryset = request.user.grades
del form.fields['share']
render['form'] = form
return render_to_response('test.html', render)
elif mode == 'edit':
form = TestForm(request.POST,
instance=get_object_or_404(Test, id=id))
if form.is_valid():
form.save()
return HttpResponseRedirect('/tests/test/')
else:
form.fields['subject'].queryset = request.user.subjects
form.fields['grades'].queryset = request.user.grades
del form.fields['share']
render['form'] = form
return render_to_response('test.html', render)
else:
return HttpResponseRedirect('/tests/test/')
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 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_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_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)
def test_layout_fieldset_row_html_with_unicode_fieldnames(self):
form_helper = FormHelper()
form_helper.add_layout(
Layout(
Fieldset(
u'Company Data',
u'is_company',
css_id = "fieldset_company_data",
css_class = "fieldsets",
title = "fieldset_title",
test_fieldset = "123"
),
Fieldset(
u'User Data',
u'email',
Row(
u'password1',
u'password2',
css_id = "row_passwords",
css_class = "rows",
),
HTML('<a href="#" id="testLink">test link</a>'),
HTML(u"""
{% if flag %}{{ message }}{% endif %}
"""),
u'first_name',
u'last_name',
)
)
)
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{% crispy form form_helper %}
""")
c = Context({
'form': TestForm(),
'form_helper': form_helper,
'flag': True,
'message': "Hello!",
})
html = template.render(c)
self.assertTrue('id="fieldset_company_data"' in html)
self.assertTrue('class="fieldsets' in html)
self.assertTrue('title="fieldset_title"' in html)
self.assertTrue('test-fieldset="123"' in html)
self.assertTrue('id="row_passwords"' in html)
if settings.CRISPY_TEMPLATE_PACK == 'uni_form':
self.assertTrue('class="formRow rows"' in html)
else:
self.assertTrue('class="row rows"' in html)
self.assertTrue('Hello!' in html)
self.assertTrue('testLink' in html)
def index(request):
if request.method == 'GET':
form = TestForm()
tests = Test.objects.all()
args = {'form': form, 'tests': tests}
return render(request, 'testmanager/home.html', args)
elif request.method == 'POST':
form = TestForm(request.POST)
if form.is_valid():
dir = os.getcwd() + "/App/TestManager/"
form.save()
sub_time = form.cleaned_data['submissionTime']
target_classifier = form.cleaned_data['targetClassifier']
network_attack = form.cleaned_data['networkAttack']
adversarial_attack = form.cleaned_data['addAttackType']
results = form.cleaned_data['results']
test = Test.objects.all().last()
test.description = test_description(test.addAttackType)
test.save()
# Test manager executed
cmd = "sudo python {}main.py '{}' '{}' '{}'".format(str(dir),
str(target_classifier), str(network_attack), str(adversarial_attack))
Popen(['gnome-terminal', '-e', cmd], stdout=PIPE)
results_dir = dir + "test_results/results.txt"
open(results_dir,"w")
while(test_result(results_dir) == '-1'):
time.sleep(5)
test = Test.objects.all().last()
test.results = test_result(results_dir)
test.save()
return redirect('index')
args = {'form': form, 'submissionTime':submissionTime}
return render(request, 'testmanager/home.html', args)
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_classes_filter(self):
template = get_template_from_string(u"""
{% load crispy_forms_field %}
{{ testField|classes }}
""")
test_form = TestForm()
test_form.fields['email'].widget.attrs.update({'class': 'email-fields'})
c = Context({'testField': test_form.fields['email']})
html = template.render(c)
self.assertTrue('email-fields' in html)
