def updateControllerMode_ajax(request):
"""Update the mode of the Dolphin Controller"""
team, release = getTeamAndReleaseIDFromSession(request.session)
controller = ControllerInfo.objects.get(team_id=team, release_id=release)
try:
modeService = RegressionServices.objects.get(service_type=RegressionServices.SERVICE_TYPE_CONTROLLER_MODE)
except RegressionServices.MultipleObjectsReturned:
modeService = RegressionServices.objects.get(controller=controller, service_type=RegressionServices.SERVICE_TYPE_CONTROLLER_MODE)
oldMode = controller.getRequest(modeService.service_url) or None
newMode = request.POST.get('value')
# Set the new mode
try:
result = controller.restRequest('POST', modeService.service_url, newMode)
mode = controller.getRequest(modeService.service_url) or None
# Actually want to test for True, since a failure is usually a string of error messages
if result == True:
return HttpResponse(ControllerModes.CONTROLLER_MODES_MAPPING_DICT[mode]+" (Click to Edit)")
else:
return HttpResponse(ControllerModes.CONTROLLER_MODES_MAPPING_DICT[mode]+" (Click to Edit)")
except :
return HttpResponse(ControllerModes.CONTROLLER_MODES_MAPPING_DICT[oldMode]+" (Click to Edit)")
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 requestControllerSelfTest(request):
team, release = getTeamAndReleaseIDFromSession(request.session)
controller = ControllerInfo.objects.get(team_id=team, release_id=release)
# Get the service URLs for this controller, check if a specific one exists,
# and take the default if it does not
try:
stSvc = RegressionServices.objects.get(service_type=RegressionServices.SERVICE_TYPE_CONTROLLER_SELFTEST)
except RegressionServices.MultipleObjectsReturned:
stSvc = RegressionServices.objects.get(controller=controller,
service_type=RegressionServices.SERVICE_TYPE_CONTROLLER_SELFTEST)
success = controller.getRequest(stSvc.service_url)
return JSONHttpResponse({'success': success}, status={True: 200, False: 500}[success])
def displayIssues(request):
"""
View the list of all tests which are currently failing, including the option to assign an issue
"""
team, release = getTeamAndReleaseIDFromSession(request.session)
# Get all logs from active planned executions within current team/release which have failing requirements
latestTestLogs = LatestTestLog.objects.filter(
Q(planned_exec__team=team) &
Q(planned_exec__release=release) &
Q(planned_exec__end_date=None) &
~Q(testlog__failed_reqs=''))
objContext = RequestContext(request)
return render_to_response('issues/issues_home.html', {'latestTestLogs': latestTestLogs}, objContext)
def getRawStationProfile_ajax(request, station):
"""
Retrieves the test station info from the Dolphin system and formats the data
for a dialog box with pprint.
"""
resp = {'status': False, 'msg': None}
# Get Station Information
team, release = getTeamAndReleaseIDFromSession(request.session)
controller = ControllerInfo.objects.get(team=team,release=release)
stationInfo = getAgentStationInfo(station, controller)
if stationInfo:
resp['msg'] = pprint.pformat(stationInfo)
resp['status'] = True
else:
resp['msg'] = "An Error occurred when attempting to contact this test station."
return JSONHttpResponse(resp)
def getControllerInfo(request):
"""Retrieves the various information about the Dolphin controller"""
team, release = getTeamAndReleaseIDFromSession(request.session)
controller = ControllerInfo.objects.get(team_id=team, release_id=release)
# Get the service URLs for this controller, check if a specific one exists,
# and take the default if it does not
try:
stSvc = RegressionServices.objects.get(service_type=RegressionServices.SERVICE_TYPE_CONTROLLER_SELFTEST)
except RegressionServices.MultipleObjectsReturned:
stSvc = RegressionServices.objects.get(controller=controller,
service_type=RegressionServices.SERVICE_TYPE_CONTROLLER_SELFTEST)
try:
vSvc = RegressionServices.objects.get(service_type=RegressionServices.SERVICE_TYPE_CONTROLLER_VERSION)
except RegressionServices.MultipleObjectsReturned:
vSvc = RegressionServices.objects.get(controller=controller,
service_type=RegressionServices.SERVICE_TYPE_CONTROLLER_VERSION)
try:
mSvc = RegressionServices.objects.get(service_type=RegressionServices.SERVICE_TYPE_CONTROLLER_MODE)
except RegressionServices.MultipleObjectsReturned:
mSvc = RegressionServices.objects.get(controller=controller,
service_type=RegressionServices.SERVICE_TYPE_CONTROLLER_MODE)
try:
eSvc = RegressionServices.objects.get(service_type=RegressionServices.SERVICE_TYPE_ENVIRONMENT_INFO)
except RegressionServices.MultipleObjectsReturned:
eSvc = RegressionServices.objects.get(controller=controller,
service_type=RegressionServices.SERVICE_TYPE_ENVIRONMENT_INFO)
objContext = RequestContext(request, {'version': controller.getRequest(vSvc.service_url) or None,
'mode': ControllerModes.CONTROLLER_MODES_MAPPING_DICT[controller.getRequest(mSvc.service_url) or None],
'env': controller.getRequest(eSvc.service_url) or None,
'controller': controller,
'admins': settings.ADMINS})
return render_to_response('dolphace/controller.html', objContext)
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 getTraceabilityLists_ajax(request):
team, release = getTeamAndReleaseIDFromSession(request.session)
cases = Case.active.filter(protocol__team=team, protocol__release=release, protocol__end_date__isnull=True).exclude(exec_type='TR').select_related('protocol','case','test')
latestTestLogs = LatestTestLog.objects.filter(planned_exec__team=team, planned_exec__release=release, planned_exec__end_date=None
).select_related('testlog', 'testlog__case', 'testlog__case__test', 'testlog__protocol')
plannedExecutions = Planned_Exec.active.filter(team=team, release=release
).select_related('protocol','case__test', 'case')
# Create default dicts as follows:
# reqs_dict: Protocol > Test > Case > description > set
# run_count: Protocol > Test > Case > counter
# logs_only: Protocol > Test > Case > requirement > information
# prot_only: Protocol > Test > Case > information
reqs_dict = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: defaultdict(set)))) # For tracking reqs found in protocols and logs
run_count = defaultdict(lambda: defaultdict(lambda: defaultdict(Counter))) # For tracking execution information
logs_only = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: defaultdict(dict)))) # For tracking information about requirements found only in logs
prot_only = defaultdict(lambda: defaultdict(lambda: defaultdict(dict))) # For tracking information about requirements only found in protocols
dataTables = {'logs':{'aaData': [], 'status': True},
'protocols':{'aaData': [], 'status': True}}
# Add to dictionary the requirements which are present in protocols
for case in cases:
# Sanitize input
p = case.protocol.name.lower()
t = case.test.name.lower()
c = case.name.lower()
reqs = set()
[reqs.add(prot_req.rstrip('.pP')) for prot_req in case.requirements.split()]
reqs_dict[p][t][c]['protocol_reqs'] = reqs
# Add other information as well
reqs_dict[p][t][c]['protocol_id'] = case.protocol.id
reqs_dict[p][t][c]['case_id'] = case.id
reqs_dict[p][t][c]['stream_version'] = case.protocol.stream_version
# Scan through logs to determine what requirements are parsed, and update the 'logs_only' list as well
for log in latestTestLogs:
# Sanitize input
p = log.testlog.protocol.name.lower()
t = log.testlog.case.test.name.lower()
c = log.testlog.case.name.lower()
# Build set of all requirements parsed from log
reqs = set()
[reqs.add(log_req.rstrip('.pP')) for log_req in log.testlog.passed_reqs.split(', ') if log_req]
[reqs.add(log_req.rstrip('.pP')) for log_req in log.testlog.failed_reqs.split(', ') if log_req]
# Logs with exceptions should be noted, as the exception could account for a missing requirement
if log.testlog.sys_error:
run_count[p][t][c]['Exceptions'] += 1
# Add requirements which have been found to the overall dictionary, for tracking
reqs_dict[p][t][c]['testlog_reqs'] = reqs_dict[p][t][c]['testlog_reqs'].union(reqs)
# If a requirement from the log is not in the protocol, keep track of the log where this requirement originated
if not reqs.issubset(reqs_dict[p][t][c]['protocol_reqs']):
for req in reqs - reqs_dict[p][t][c]['protocol_reqs']:
# If this requirement wasn't already being tracked here, track it now
if not logs_only[p][t][c].has_key(req):
logs_only[p][t][c][req] = {
'protocol_id': log.testlog.protocol.id,
'case_id': log.testlog.case.id,
# These three will make the DB query much slower, so keeping them out if possible
#'pg': log.testlog.testplan.plm.pg_model,
#'external': log.testlog.testplan.plm.comm_model,
#'country': log.testlog.testplan.country
'run date': log.testlog.test_starttime,
'log_id': log.testlog_id,
'build': log.testlog.build,
'script_ver': log.testlog.test_version
}
# Get execution information, so we can report the number of executions executed
# and not run when reporting protocol requirements not found in logs
for plExec in plannedExecutions:
p = plExec.protocol.name.lower()
t = plExec.case.test.name.lower()
c = plExec.case.name.lower()
if not reqs_dict[p][t][c]:
logger.info("An execution was found for a protocol test case combination which should not exist:")
logger.info("\t%s\n\t%s\n\t$s" % (p, t, c))
raise Exception("Error encountered during generation of report")
else:
run_count[p][t][c][plExec.exec_state.lower()] += 1
# Assemble response for logs_only
for p in logs_only.keys():
for t in logs_only[p].keys():
for c in logs_only[p][t].keys():
for req in logs_only[p][t][c].keys():
row = [p,
reverse('protocol_detail', args=[logs_only[p][t][c][req]['protocol_id']]),
t,
c,
reverse('case_detail', args=[logs_only[p][t][c][req]['case_id']]),
req,
logs_only[p][t][c][req]['run date'].strftime("%m/%d/%y %H:%M:%S"),
logs_only[p][t][c][req]['log_id'],
logs_only[p][t][c][req]['build'],
logs_only[p][t][c][req]['script_ver']]
dataTables['logs']['aaData'].append(row)
# Assemble response for protocols_only
for p in reqs_dict.keys():
for t in reqs_dict[p].keys():
for c in reqs_dict[p][t].keys():
if run_count[p][t][c]: # Only include cases for which there are actual executions (to avoid all the empty traceability cases)
untracedReqs = reqs_dict[p][t][c]['protocol_reqs'] - reqs_dict[p][t][c]['testlog_reqs']
if untracedReqs:
row = [p,
reverse('protocol_detail', args=[reqs_dict[p][t][c]['protocol_id']]),
t,
c,
reverse('case_detail', args=[reqs_dict[p][t][c]['case_id']]),
', '.join(untracedReqs),
reqs_dict[p][t][c]['stream_version'],
run_count[p][t][c]
]
dataTables['protocols']['aaData'].append(row)
return JSONHttpResponse(dataTables)
def getStationInfo_ajax(request):
"""
Retrieves the test station info from the Dolphin system and formats the data
for a dataTable. Additionally, retrieves the Dolphin controller info.
"""
team, release = getTeamAndReleaseIDFromSession(request.session)
controller = ControllerInfo.objects.get(team_id=team, release_id=release)
try:
tsSvc = RegressionServices.objects.get(service_type=RegressionServices.SERVICE_TYPE_TESTSTATION_INFO)
except RegressionServices.MultipleObjectsReturned:
tsSvc = RegressionServices.objects.get(controller=controller, service_type=RegressionServices.SERVICE_TYPE_TESTSTATION_INFO)
stations = controller.getRequest(tsSvc.service_url) or []
try:
mSvc = RegressionServices.objects.get(service_type=RegressionServices.SERVICE_TYPE_CONTROLLER_MODE)
except RegressionServices.MultipleObjectsReturned:
mSvc = RegressionServices.objects.get(controller=controller,
service_type=RegressionServices.SERVICE_TYPE_CONTROLLER_MODE)
mode = controller.getRequest(mSvc.service_url) or None
# Begin formatting the data
dataTables = {'aaData': [], 'status': False, 'controller': controller.hostname, 'controller_mode': ControllerModes.CONTROLLER_MODES_MAPPING_DICT[mode]}
# Test station staus
tsStatus = TestStationModes.objects.all()
# Keys to mine from response data
tsKeys = {
'pg': {
'type': 'Details.Hardware.PulseGenerator.Type',
'status': 'Details.Hardware.PulseGenerator.Status',
'family': 'Details.Hardware.PulseGenerator.PGFamily',
'band': 'Details.Hardware.PulseGenerator.RFBand',
'version': 'Details.Hardware.PulseGenerator.FirmwareVersion',
'model': 'Details.Hardware.PulseGenerator.ModelNumber',
},
'comm': {
'id': 'Details.Hardware.Communicator.ID',
'status': 'Details.Hardware.Communicator.Status',
'model': 'Details.Hardware.Communicator.ModelNumber',
'region': 'Details.Hardware.Communicator.Region',
'version': 'Details.Hardware.Communicator.BundleVersion'
},
'bpm': {
'status': 'Details.Hardware.BloodPressureMonitor.Status',
},
'ws': {
'status': 'Details.Hardware.WeightScale.Status'
},
'testlibs_list': {
'libs': 'Details.Software.TestLibs',
},
'testlib': {
'name': 'Name',
'version': 'Version'
}
}
# Loop through the test stations sent by the regression system
for s in stations:
# only the stations in this team/release cluster
if controller.cluster_name not in s['ClusterNames']:
continue
# PG Type/Info
pgInfo = render_to_string('dolphace/pginfo.html', {'pg': safeDictLookup(tsKeys['pg'], s)})
# Communicator Info
commInfo = render_to_string('dolphace/comminfo.html', {'device': safeDictLookup(tsKeys['comm'], s)})
# Sensor Info
sensorInfo = render_to_string('dolphace/sensorinfo.html',
{'bpm': safeDictLookup(tsKeys['bpm'], s),
'ws': safeDictLookup(tsKeys['ws'], s)})
# Test Libraries
testLibs = safeDictLookup(tsKeys['testlibs_list'], s)
testLibsList = []
if testLibs['libs']:
for lib in testLibs['libs']:
testLibsList.append(safeDictLookup(tsKeys['testlib'], lib))
versionInfo = getAgentProductInfo(s['Name'], controller)
if versionInfo:
version = versionInfo['Version']
else:
version = "Not Found"
try:
theStatus = tsStatus.get(mode_num=s['Status'])
if theStatus:
status = theStatus.get_mode_display()
else:
raise Exception()
except:
status = "Unknown status: %s" % s['Status']
# Fill the table out
dataTables['aaData'].append([
cleanEOLCharacters(render_to_string('dolphace/teststation_detail_link.html', {'ts': s, 'version': version})),
cleanEOLCharacters(status),
cleanEOLCharacters(commInfo),
cleanEOLCharacters(pgInfo),
cleanEOLCharacters(sensorInfo),
cleanEOLCharacters(render_to_string('dolphace/testlibinfo.html', {'testlibs': testLibsList}))])
dataTables['status'] = True
return JSONHttpResponse(dataTables)
def getWorkorderQueue_ajax(request):
"""
Retrieves the workorder queue from the Dolphin system and formats the data
for a dataTable
"""
team, release = getTeamAndReleaseIDFromSession(request.session)
controller = ControllerInfo.objects.get(team_id=team, release_id=release)
try:
qSvc = RegressionServices.objects.get(service_type=RegressionServices.SERVICE_TYPE_WORKORDER_JOBS)
except RegressionServices.MultipleObjectsReturned:
qSvc = RegressionServices.objects.get(controller=controller, service_type=RegressionServices.SERVICE_TYPE_WORKORDER_JOBS)
queue = controller.getRequest(qSvc.service_url) or []
dataTables = {'aaData': [], 'status': False, 'msg': ''}
attrs = ['testplan__case__env_type',
'testplan__case__pg_type',
'batch__name',
'batch_id',
'workorder_id',
'workorder_text',
'submission_time',
'testplan__protocol__name',
'testplan__protocol_id',
'testplan__case_id',
'testplan__case__test__name',
'testplan__case__name',
'testplan__plm__comm_model',
'testplan__plm__pg_model',
'testplan__plm__geography',
'testplan__country__name',
'testplan_id',
]
wos = WorkOrder.objects.filter(workorder_id__in=queue).values(*attrs)
# Loop through the workorders sent by the regression system
try:
for wo in wos:
batch = cleanEOLCharacters(render_to_string('batch/batch_name.html', \
{'batch_name': wo['batch__name'],
'batch_id': wo['batch_id']}))
ptc = cleanEOLCharacters(render_to_string('testplan/datatables_ptc_structure.html',\
{'protocol_id': wo['testplan__protocol_id'],
'protocol_name': wo['testplan__protocol__name'],
'test_name': wo['testplan__case__test__name'],
'case_id': wo['testplan__case_id'],
'case_name': wo['testplan__case__name'],
'show_detail_link': True,
'testplan_id': wo['testplan_id']}))
plm = cleanEOLCharacters(render_to_string('testplan/datatables_plm_structure.html',\
{'geography': wo['testplan__plm__geography'],
'testplan_country': wo['testplan__country__name'],
'pg_model': wo['testplan__plm__pg_model'],
'comm_model': wo['testplan__plm__comm_model']}))
try:
woDict = ast.literal_eval(wo['workorder_text'])
pgType = woDict['Hardware']['PulseGenerator']['Type']
except:
pgType = EQUIP_PG_CHOICES_DICT[wo['testplan__case__pg_type']]
dataTables['aaData'].append([
wo['workorder_id'],
ptc,
plm,
Case.ENVIRONMENT_CHOICES_DICT[wo['testplan__case__env_type']],
pgType,
batch,
wo['submission_time'].strftime('%m/%d/%Y %H:%M')
])
except Exception as e:
dataTables['msg'] = "An error occurred: " + e.message
return JSONHttpResponse(dataTables, status=500)
dataTables['status'] = True
return JSONHttpResponse(dataTables)
