def ownerUpdate_ajax(request, pid):
"""
Handles the ajax request to update the case owner
"""
owner = request.GET.get('owner')
recursion = {'true':True,'false':False}[str(request.GET.get('recursion'))]
try:
c = Case.objects.get(id=pid)
old_owner = c.owner
c.owner = owner
c.save()
# Update all of the planned executions as well if specified on the form
if recursion:
testplan = Planned_Exec.active.filter(case=c)
for test in testplan:
test.owner = c.owner
test.save()
# Log the changes
if owner != old_owner:
utils_protocol.logProtocol(request.user, c.protocol, "COC", case_name=c.name, owner=owner, old_owner=old_owner)
# Reply back with the link to the protocol owner
msg = convert_gnumber_link(c.owner)
except:
msg = "Failure"
return HttpResponse(msg)
def getProtocolActivityTable_ajax(request, pid):
"""Returns the protocol activity for a given pid from HTTP GET ajax reqest"""
try:
plogs = ProtocolActivityLog.objects.filter(protocol=pid)[:50]
except:
msg = 'No Protocol Activity was found for this protocol'
return HttpResponse(JSONEncoder().encode({'status': False,'message': msg}), status=500)
# dataTables plugin requires only a JSON-formatted list named "aaData"
# http://www.datatables.net/examples/data_sources/ajax.html
dataTables = {"aaData": []}
for log in plogs:
try:
if log.protocol_version is None:
version = 'Not recorded'
else:
version = log.protocol_version
dataTables['aaData'].append([log.activity_timestamp.strftime("%m/%d/%y %H:%M:%S"),
convert_gnumber_link(log.logger),
version,
format_log_msg(log)])
except:
dataTables['status'] = False
dataTables['msg'] = 'Unable to retrieve this protocol activity log.'
dataTables['aaData'].append(['--','--','--',dataTables['msg'] ])
return JSONHttpResponse(dataTables)
def populateFailingLogs_ajax(request):
"""Returns the failing tests list table of a project, listing all current failing tests"""
team, release = getTeamAndReleaseIDFromSession(request.session)
releaseObj = Release.objects.get(id=release)
isActive = releaseObj.project.isActive()
# Get all logs from active planned executions within current team/release which have failing requirements
latestTestLogs = LatestTestLog.objects.select_related(
#'planned_exec',
'planned_exec__case',
'planned_exec__case__test',
'planned_exec__protocol',
'planned_exec__plm',
'testlog',
).filter(
planned_exec__team=team,
planned_exec__release=release,
planned_exec__end_date=None,
testlog__passed=False
)
issues = Issue.active.filter(
#testlog__testplan__team=team,
#testlog__testplan__release=release,
end_date=None
)
issueDict = defaultdict(list)
[issueDict[issue.testlog_id].append(issue) for issue in issues]
dataTables = {'aaData': [], 'status': False}
for ltl in latestTestLogs:
ptcase = cleanEOLCharacters(render_to_string('issues/view_protocol_test_case.html', {'pe': ltl.planned_exec}))
plannedExec = cleanEOLCharacters(render_to_string('issues/view_planned_exec.html', {'planned_exec': ltl.planned_exec}))
gnum = cleanEOLCharacters(convert_gnumber_link(ltl.planned_exec.owner))
reqs = cleanEOLCharacters(reduce_to_set(ltl.testlog.failed_reqs))
viewLog = cleanEOLCharacters(render_to_string('issues/view_log_button.html', {'testLogId': ltl.testlog_id}))
issues = ltl.testlog.issue_set.all()
if issueDict.has_key(ltl.testlog_id):
issueLink = cleanEOLCharacters(render_to_string('issues/view_tracker_links.html',
{'issues': issueDict[ltl.testlog_id],
'JIRA_URL_PREFIX': settings.JIRA_URL_PREFIX,
'RTC_URL_PREFIX': settings.RTC_URL_PREFIX}))
elif isActive:
issueLink = cleanEOLCharacters(render_to_string('issues/report_issues_button.html', {'testlog_id': ltl.testlog_id}))
else:
issueLink = "N/A"
dataTables['aaData'].append([ptcase,
plannedExec,
gnum,
reqs,
ltl.testlog.test_starttime.strftime("%m/%d/%y %H:%M:%S"),
issueLink,
viewLog])
return JSONHttpResponse(dataTables)
def ownerUpdate_ajax(request, pid):
"""
Handles the ajax request to update the protocol owner
"""
owner = request.GET.get('owner')
recursion = {'true':True,'false':False}[str(request.GET.get('recursion'))]
try:
p = Protocol.objects.get(id=pid)
old_owner = p.owner
p.owner = owner
p.save()
# Update the tests, regardless of whether recursive was selected or
# not. Tests don't really have too much meaning here
tests = Test.active.filter(protocol=p)
for test in tests:
test.owner = p.owner
test.save()
# Update all of the cases and planned executions as well
if recursion:
cases = Case.active.filter(protocol=p)
for case in cases:
case.owner = p.owner
case.save()
testplan = Planned_Exec.active.filter(protocol=p)
for test in testplan:
test.owner = p.owner
test.save()
# Log the changes
if owner != old_owner:
logProtocol(request.user, p, "POC", owner=owner, old_owner=old_owner)
# Reply back with the link to the protocol owner
msg = convert_gnumber_link(p.owner)
except:
msg = "Failure"
return HttpResponse(msg)
def populateIssueList(request, user=None):
"""Returns the current issues in a project"""
team, release = getTeamAndReleaseIDFromSession(request.session)
latestTestLogs = LatestTestLog.objects.all().values('testlog')
query = Q(testlog__testplan__team=team) & \
Q(testlog__testplan__release=release) & \
Q(testlog__in=latestTestLogs) & \
Q(end_date=None)
if user:
username = FortyTwoUser.objects.get(id=user).username
query.add(Q(owner=username), Q.AND)
issues = Issue.objects.filter(query)
dataTables = {'aaData': []}
for issue in issues:
link = cleanEOLCharacters(render_to_string('issues/view_tracker_link.html',
{'issue': issue,
'JIRA_URL_PREFIX': settings.JIRA_URL_PREFIX,
'RTC_URL_PREFIX': settings.RTC_URL_PREFIX}))
viewLog = cleanEOLCharacters(render_to_string('issues/view_log_button.html', {'testLogId': issue.testlog_id}))
plannedExec = cleanEOLCharacters(render_to_string('issues/view_planned_exec.html', {'planned_exec': issue.testlog.testplan}))
ptcase = cleanEOLCharacters(render_to_string('issues/view_protocol_test_case.html', {'pe': issue.testlog.testplan}))
if issue.expected_failure:
expected = 'Yes'
else:
expected = 'No'
dataTables['aaData'].append([convert_gnumber_link(issue.owner),
link,
issue.get_issue_type_display(),
ptcase,
plannedExec,
issue.requirements,
issue.testlog.build,
expected,
viewLog,])
return JSONHttpResponse(dataTables)
def populateTestLogTable_ajax(request,pid):
"""Retrieves all of the test logs for a given planned execution id as JSON objects for datatables"""
try:
test_logs = TestLog.objects.filter(testplan=pid)
except TestLog.DoesNotExist:
msg = 'No Test Logs exist for this planned execution'
return HttpResponse(JSONEncoder().encode({'status': False,'message': msg}), status=500)
except:
msg = 'Unknown Error'
return HttpResponse(JSONEncoder().encode({'status': False,'message': msg}), status=500)
# Get controller information for link to controller logfile dir
team, release = getTeamAndReleaseIDFromSession(request.session)
try:
controller = ControllerInfo.objects.get(team=team, release=release)
workOrdersForPID = WorkOrder.objects.filter(testplan = pid)
workOrdersDict = {w.testlog_id : w for w in workOrdersForPID if w.testlog_id}
except:
controller = None
# dataTables plugin requires only a JSON-formatted list named "aaData"
# http://www.datatables.net/examples/data_sources/ajax.html
dataTables = {"aaData": []}
# Loop through the logs and output what the table needs
for log in test_logs:
if log.exception_json is None or log.exception_json == '':
exception_text = json.dumps({'etext': 'None found', 'etype': None})
elif json.loads(log.exception_json) is None:
exception_text = json.dumps({'etext': 'None found', 'etype': None})
else:
exception_text = log.exception_json
# If this team/release uses dolphin, and this log was executed on dolphin, and the result was parsed successfully
if controller and workOrdersDict.has_key(log.id) and workOrdersDict[log.id].result_test_starttime:
workorderDir = os.path.join(controller.hostname,
controller.loglocation,
workOrdersDict[log.id].result_test_starttime.strftime("%m_%d_%Y").lstrip('0').replace('_0', '_'),
workOrdersDict[log.id].workorder_id)
workorderDir = r'\\' + workorderDir
dolphinLogDir = cleanEOLCharacters(render_to_string('testplan/dolphin_logfolder_cell.html',
{'dir':workorderDir}))
else:
dolphinLogDir = None
dataTables['aaData'].append([{True:'Pass', False:'Fail'}[log.passed],
log.build or "",
log.test_version or "",
log.test_starttime.strftime("%m/%d/%y %H:%M:%S"),
"{0:.2f}".format(log.test_runtime/60.0),
dolphinLogDir or "",
convert_gnumber_link(log.test_engineer),
log.test_station,
log.test_system_name or "",
"Verify: %s-%s<br />Ensure: %s-%s</br />Validate: %s-%s<br />SysErr: %s" % (log.verify_pass, log.verify_fail, log.ensure_pass, log.ensure_fail, log.validate_pass, log.validate_fail, log.sys_error),
render_to_string('batch/exception_text_cell.html', { 'model': log, 'exception': json.loads(exception_text)}),
log.id])
return HttpResponse(json.dumps(dataTables), content_type = 'application/json; charset=utf8')
def format_log_msg(logObj):
"""
Using the log object, format the meta information from the object into a meaningful
message to the user.
"""
msg = ""
# Protocol imported from Version Control System Successfully
if logObj.message_type == "PRI":
testSuffix = ""
caseSuffix = ""
testCount = logObj.meta.split(",")[0]
caseCount = logObj.meta.split(",")[1]
if int(testCount) > 1: testSuffix = "s"
if int(caseCount) > 1: caseSuffix = "s"
msg = "Protocol imported from the VCS with "+testCount+" test"+testSuffix+" and "+caseCount+" case"+caseSuffix+"."
# Protocol Refresh
elif logObj.message_type == "PRF":
newVersion, oldVersion = logObj.meta.split(',')
msg = "Protocol refreshed from %s to %s." % (oldVersion, newVersion)
# Protocol initially assigned to gNumber
elif logObj.message_type == "POA":
msg = "Protocol owner assigned to %s." % convert_gnumber_link(logObj.meta)
# Protocol Inactivated
elif logObj.message_type == "PRN":
msg = "Protocol deactivated by %s." % convert_gnumber_link(logObj.meta)
# Protocol Reactivation
elif logObj.message_type == "PRR":
msg = "Protocol reactivated by %s." % convert_gnumber_link(logObj.meta)
# Protocol has been reassigned
elif logObj.message_type == "POC":
newOwner = logObj.meta.split(',')[0]
oldOwner = logObj.meta.split(',')[1]
msg = "Protocol ownership reassigned to %s from %s." % ( convert_gnumber_link(newOwner), convert_gnumber_link(oldOwner) )
# Protocol state has been updated
elif logObj.message_type == "PSU":
newState = logObj.meta.split(',')[0]
oldState = logObj.meta.split(',')[1]
if oldState == "None":
msg = "Protocol state set to %s." % newState
else:
msg = "Protocol state changed from %s to %s." % (oldState, newState)
# Case Option "PRM" was modified
elif logObj.message_type == "COP":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s value for PRM equipment was changed to %s." % (name, value)
# Case Option "Machsim" was modified
elif logObj.message_type == "COM":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s value for Machsim equipment was changed to %s." % (name, value)
# Case Option "shield_box" was modified
elif logObj.message_type == "COS":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s value for Shield box equipment was changed to %s." % (name, value)
# Case Option "PG Type" was modified
elif logObj.message_type == "CPG":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s pulse generator type equipment was changed to %s." % (name, value)
# Case Option "Sensor Type" was modified
elif logObj.message_type == "CST":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s external sensor type equipment was changed to %s." % (name, value)
# Case Option "Environment Type" was modified
elif logObj.message_type == "CET":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s testing environment type was changed to %s." % (name, value)
# Case Option "Execution Type" was modified
elif logObj.message_type == "CEE":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s test execution type was changed to %s." % (name, value)
# Case Option "Automation state" was modified
elif logObj.message_type == "CAS":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s test automation development state was changed to %s." % (name, value)
# Case Option "SVMachsim" was modified
elif logObj.message_type == "CSV":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s value for SVMachsim equipment was changed to %s." % (name, value)
# Case Option "Teltone" was modified
elif logObj.message_type == "CTE":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s value for Teltone equipment was changed to %s." % (name, value)
# Case Option "Telephone" was modified
elif logObj.message_type == "CTL":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s value for telephone equipment was changed to %s." % (name, value)
# Planned Execution was added
elif logObj.message_type == "PEA":
name = logObj.meta.split(',')[0]
id = logObj.meta.split(',')[1]
region = logObj.meta.split(',')[2]
pg_model = logObj.meta.split(',')[3]
comm_model = logObj.meta.split(',')[4]
browser = logObj.meta.split(',')[5]
if browser == BROWSER_OPTIONS[0][1]:
browser = ''
# Country was added later, so not all log messages of this type have it
try:
country = logObj.meta.split(',')[6]
msg = 'Test List item for %s added: %s (%s), %s, %s, %s' % (create_planned_exec_created_case_link(logObj.meta), region, country, pg_model, comm_model, browser)
except IndexError:
msg = 'Test List item for %s added: %s, %s, %s, %s' % (create_planned_exec_created_case_link(logObj.meta), region, pg_model, comm_model, browser)
# Case Option "Centricity" was modified
elif logObj.message_type == "CCT":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s testing centricity was changed to %s." % (name, value)
# Case Option "Comm Connection" was modified
elif logObj.message_type == "CCC":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s communicator connection type was changed to %s." % (name, value)
# Test Log Parsing Success
elif logObj.message_type == "TLS":
# Get individual meta data
protocol_name = logObj.meta.split(',')[0]
case_name = logObj.meta.split(',')[1]
test_name = logObj.meta.split(',')[2]
pg_model = logObj.meta.split(',')[3]
external = logObj.meta.split(',')[4]
browser = logObj.meta.split(',')[5]
testplan = logObj.meta.split(',')[6].strip()
msg = 'Successfully parsed a test log (%s) for %s, %s, %s, with pg = %s, external = %s, and browser = %s' % (convert_planned_exec_link(testplan), protocol_name, test_name, case_name, pg_model, external, browser)
# Test Log Parsing Failure
elif logObj.message_type == "TLF":
msg = "Log Parsing Failure"
# Test Log Parsing Incomplete
elif logObj.message_type == "TLI":
# Get individual meta data
protocol_name = logObj.meta.split(',')[0]
case_name = logObj.meta.split(',')[1]
test_name = logObj.meta.split(',')[2]
msg = "<div id='view_details'>Incomplete Log File: " \
"<div title='<p>Test: <b>%s</b></p>" \
"<p>Case: <b>%s</b></p>'" \
" style='display:inline;'>Mouse over to view details.</div>" \
% (test_name, case_name)
# Case has been reassigned
elif logObj.message_type == "COC":
case = logObj.meta.split(',')[0]
newOwner = logObj.meta.split(',')[1]
oldOwner = logObj.meta.split(',')[2]
msg = "%s ownership reassigned to %s from %s." % ( case, convert_gnumber_link(newOwner), convert_gnumber_link(oldOwner) )
# Case automation owner has been assigned
elif logObj.message_type == "CAO":
case = logObj.meta.split(',')[0]
newOwner = logObj.meta.split(',')[1]
msg = "%s automation ownership assigned to %s." % ( case, convert_gnumber_link(newOwner) )
# Planned Execution was deleted
elif logObj.message_type == "PED":
name = logObj.meta.split(',')[0]
id = logObj.meta.split(',')[1]
region = logObj.meta.split(',')[2]
pg_model = logObj.meta.split(',')[3]
comm_model = logObj.meta.split(',')[4]
browser = logObj.meta.split(',')[5]
msg = 'Test List item for %s has been deleted: %s, %s, %s, %s' % (create_planned_exec_created_case_link(logObj.meta), region, pg_model, comm_model, browser)
# Planned Execution was deactivated
elif logObj.message_type == "PDD":
name = logObj.meta.split(',')[0]
id = logObj.meta.split(',')[1]
region = logObj.meta.split(',')[2]
pg_model = logObj.meta.split(',')[3]
comm_model = logObj.meta.split(',')[4]
browser = logObj.meta.split(',')[5]
msg = 'Test List item for %s has been deactivated: %s, %s, %s, %s' % (create_planned_exec_created_case_link(logObj.meta), region, pg_model, comm_model, browser)
# Case Option "USB Relay Type" was modified
elif logObj.message_type == "CUT":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s external USB relay type equipment was changed to %s." % (name, value)
# Case Option "Comm Cellular Type" was modified
elif logObj.message_type == "CCL":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s external cellular type equipment was changed to %s." % (name, value)
# Case Option "Comm Mode" was modified
elif logObj.message_type == "CCM":
name = logObj.meta.split(',')[0]
value = logObj.meta.split(',')[1]
msg = "%s external mode was changed to %s." % (name, value)
# Message is not defined
else:
msg = "This message cannot be displayed."
return msg
def populateTestListTable_ajax(request,cid):
"""
Send back the planned_exec fields for the test list table in the case detail/test list tab
Inputs:
cid - case_id for the requested case
"""
try:
test_list = Planned_Exec.objects.filter(case=cid).select_related('planned_for','case','plm')
except Planned_Exec.DoesNotExist:
msg = 'Test List does not exist for this case'
except:
msg = 'Unknown Error'
# Get count of logs for each planned execution
logCount = Counter()
for log in TestLog.objects.filter(case=cid):
logCount[log.testplan_id] += 1
# Get latest testlogs for this case
latestLogs = {log.planned_exec_id : log.testlog for log in LatestTestLog.objects.filter(planned_exec__case=cid).select_related('testlog')}
release = Case.objects.get(id=cid).protocol.release_id
schedule = ProjectSchedule.getProjScheduleDict(release)
# dataTables plugin requires only a JSON-formatted list named "aaData" - http://www.datatables.net/examples/data_sources/ajax.html
dataTables = {'aaData': [], 'status': False}
# Iterate through the test list to supply the rows
for test in test_list:
# Create the checkbox
tlbox = '''<input type="checkbox" name="delete_select_%s" id="id_delete_select" />''' % str(test.id)
if test.planned_for:
planned_for = test.planned_for.name
else:
planned_for = "None"
# Create the regression options/edit link if fully automated
# TODO: This does not reflect the database values if a user has switched from FA to something else after setting regression options.
# Originally found in RTC 60655
if test.case.exec_type == 'FA':
regression_column = test.get_regression_display()
else:
regression_column = "N/A"
# Handle the deactivated planned executions a little differently
if test.end_date:
dataTables['aaData'].append([tlbox,
regression_column,
test.getDataTablesPLMBrowserStr(browser=True),
planned_for,
convert_gnumber_link(test.owner),
"Deactivated",
"N/A",
"N/A",
"N/A",
convert_planned_exec_link(test.id),
""])
elif test.exec_state == "NR":
dataTables['aaData'].append([tlbox,
regression_column,
test.getDataTablesPLMBrowserStr(browser=True),
planned_for,
convert_gnumber_link(test.owner),
test.get_exec_state_display(),
"N/A",
"N/A",
"N/A",
convert_planned_exec_link(test.id),
"zActivePE"])
else:
# Get the build and phase strings
build = str(latestLogs[test.id].build)
testDate = latestLogs[test.id].test_starttime.date()
phase_str = schedule.get(testDate.toordinal(), 'None')
dataTables['aaData'].append([tlbox,
regression_column,
test.getDataTablesPLMBrowserStr(browser=True),
planned_for,
convert_gnumber_link(test.owner),
test.get_exec_state_display(),
logCount[test.id],
latestLogs[test.id].test_starttime.strftime("%m/%d/%y %H:%M:%S"),
build+" / "+phase_str,
convert_planned_exec_link(test.id),
"zActivePE"])
dataTables['status'] = True
return JSONHttpResponse(dataTables)
