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_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_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_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_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_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(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_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 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 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_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 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_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 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 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 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 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('tests/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('tests/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('tests/test.html', render)
else:
return HttpResponseRedirect('/tests/test/')
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_form_with_helper_without_layout(self):
form_helper = FormHelper()
form_helper.form_id = "this-form-rocks"
form_helper.form_class = "forms-that-rock"
form_helper.form_method = "GET"
form_helper.form_action = "simpleAction"
form_helper.form_error_title = "ERRORS"
template = get_template_from_string(
u"""
{% load crispy_forms_tags %}
{% crispy testForm form_helper %}
"""
)
# now we render it, with errors
form = TestForm({"password1": "wargame", "password2": "god"})
form.is_valid()
c = Context({"testForm": form, "form_helper": form_helper})
html = template.render(c)
# Lets make sure everything loads right
self.assertTrue(html.count("<form"), 1)
self.assertTrue("forms-that-rock" in html)
self.assertTrue('method="get"' in html)
self.assertTrue('id="this-form-rocks"' in html)
self.assertTrue('action="%s"' % reverse("simpleAction") in html)
if settings.CRISPY_TEMPLATE_PACK == "uni_form":
self.assertTrue('class="uniForm' in html)
self.assertTrue("ERRORS" in html)
self.assertTrue("<li>Passwords dont match</li>" in html)
# now lets remove the form tag and render it again. All the True items above
# should now be false because the form tag is removed.
form_helper.form_tag = False
html = template.render(c)
self.assertFalse("<form" in html)
self.assertFalse("forms-that-rock" in html)
self.assertFalse('method="get"' in html)
self.assertFalse('id="this-form-rocks"' 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_form_with_helper_without_layout(self):
form_helper = FormHelper()
form_helper.form_id = 'this-form-rocks'
form_helper.form_class = 'forms-that-rock'
form_helper.form_method = 'GET'
form_helper.form_action = 'simpleAction'
form_helper.form_error_title = 'ERRORS'
template = get_template_from_string(u"""
{% load crispy_forms_tags %}
{% crispy testForm form_helper %}
""")
# now we render it, with errors
form = TestForm({'password1': 'wargame', 'password2': 'god'})
form.is_valid()
c = Context({'testForm': form, 'form_helper': form_helper})
html = template.render(c)
# Lets make sure everything loads right
self.assertTrue(html.count('<form'), 1)
self.assertTrue('forms-that-rock' in html)
self.assertTrue('method="get"' in html)
self.assertTrue('id="this-form-rocks"' in html)
self.assertTrue('action="%s"' % reverse('simpleAction') in html)
if (settings.CRISPY_TEMPLATE_PACK == 'uni_form'):
self.assertTrue('class="uniForm' in html)
self.assertTrue("ERRORS" in html)
self.assertTrue("<li>Passwords dont match</li>" in html)
# now lets remove the form tag and render it again. All the True items above
# should now be false because the form tag is removed.
form_helper.form_tag = False
html = template.render(c)
self.assertFalse('<form' in html)
self.assertFalse('forms-that-rock' in html)
self.assertFalse('method="get"' in html)
self.assertFalse('id="this-form-rocks"' in html)
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'),
)
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_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_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'),
)
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 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 edit_test(request, test_id):
""" Edit Test.
"""
test = get_object_or_404(Test, pk=test_id)
if request.method == "POST":
form = TestForm(request.POST, instance=test)
else:
form = TestForm(instance=test)
if form.is_valid(): # All validation rules pass
form.save()
messages.add_message(request, messages.INFO, 'The test has been successfully modified.')
return redirect(details_test, test_id=test_id)
return render_to_response('form.html',
{'form' : form,
'project' : test.project},
context_instance=RequestContext(request))
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 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 edit_test(request, test_id):
""" Edit Test.
"""
test = get_object_or_404(Test, pk=test_id)
if request.method == "POST":
form = TestForm(request.POST, instance=test)
else:
form = TestForm(instance=test)
if form.is_valid(): # All validation rules pass
form.save()
messages.add_message(request, messages.INFO,
'The test has been successfully modified.')
return redirect(details_test, test_id=test_id)
return render_to_response('form.html', {
'form': form,
'project': test.project
},
context_instance=RequestContext(request))
def metric_edit(request, metric_id):
key = request.GET.get('key', '')
if request.method == 'POST':
if key in ['QA', 'TE']:
metric = get_object_or_404(TestMetrics, pk=metric_id)
form = TestForm(request.POST, instance=metric)
elif key in ['QI', 'QE']:
metric = get_object_or_404(InnovationMetrics, pk=metric_id)
form = InnovationForm(request.POST, instance=metric)
elif key == 'RE':
metric = get_object_or_404(RequirementMetrics, pk=metric_id)
form = RequirementForm(request.POST, instance=metric)
elif key == 'TL':
metric = get_object_or_404(LabMetrics, pk=metric_id)
form = LabForm(request.POST, instance=metric)
else:
messages.error(request, 'No key to Functional Group found')
return redirect('teams:teams')
if form.is_valid():
metric = form.save()
if not metric.updated:
metric.updated = True
metric.save()
# Aggregate Subteam to Team
aggregate_subteam_to_team(metric)
context = context_teams(request)
context['key'] = key
return render(request, 'teams/teams.html', context)
else:
print form.errors
messages.error(request, 'Correct errors in the form')
context = RequestContext(request, {'metric': metric, 'form': form})
return render(request, 'teams/metric_detail.html', context)
else:
return redirect('teams:teams')
def index(request):
"""
Function handle index page form views and GET requests.
@request: request to /trs page.
@return: handled request as template with arguments.
"""
try:
tests = Test.objects.all()
for test in tests:
setattr(test, 'name', test.path.split('/')[-1])
#Handle GET request
if request.method == 'GET':
form = TestForm(request.GET)
if form.is_valid():
log.debug('index:GET: Get path: %s' % form.cleaned_data['path'])
log_file_full_path = form.cleaned_data['path'][:-3] + '.log'
log.debug("index:GET: log_file_full_path: %s" % log_file_full_path)
if request.GET.has_key('run'):
test_status = {}
# Remove .py postfix and add .log
status = os.system('python %s > %s' % (form.cleaned_data['path'], log_file_full_path))
log.debug("index:GET:run: status: %s" % status)
if status != 0:
test_status['color'] = 'red'
if status == 256:
test_status['msg'] = 'Test is fail. Please check %s' % log_file_full_path
else:
test_status['msg'] = 'Can not find test. Please provide correct pass.'
log.warning('index:GET:run: %s file can not be run. Reason: %s' %
(form.cleaned_data['path'], test_status['msg']))
else:
test_status['color'] = 'green'
test_status['msg'] = 'Test was finished.'
log.debug('index:GET:run: test_status: %s' % test_status)
return render_to_response('trs/run.html', {'tests': tests, 'test_status': test_status})
elif request.GET.has_key('show'):
logfile = []
show_error = 'Logfile is not exist or empty.'
show_result = ''
try:
for line in open(log_file_full_path):
logfile.append(line)
log.debug("index:GET:show: logfile: %s" % logfile)
except:
show_result = show_error
log.warning("index:GET:show: %s file can not be showen." % form.cleaned_data['path'])
if not logfile:
show_result = show_error
log.warning("index:GET:show: %s file can not be showen. Reason: %s" %
(form.cleaned_data['path'], show_error))
return render_to_response('trs/show.html', {'tests': tests, 'test_result': logfile,
'show_result': show_result})
else:
log.warning('Form %s is not valid.')
return render_to_response( 'trs/index.html', {'tests': tests})
except Exception as e:
log.error("index: %s" % e)
raise Http404
