def test_expand_sys_conn_result(self):
"""Test view expand_sys_conn_result."""
scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_CONNECT)
scan_job.save()
scan_job.sources.add(self.source)
# Job in created state
self.assertEqual(scan_job.status, ScanTask.CREATED)
tasks = scan_job.tasks.all()
self.assertEqual(len(tasks), 0)
# Queue job to run
scan_job.queue()
conn_task = scan_job.tasks.first()
conn_result = ConnectionResult(source=conn_task.source,
scan_task=conn_task)
conn_result.save()
sys_result = SystemConnectionResult(
name='Foo',
credential=self.cred,
status=SystemConnectionResult.SUCCESS)
sys_result.save()
conn_result.systems.add(sys_result)
conn_result.save()
result = expand_sys_conn_result(conn_result)
self.assertEqual(result[0]['credential']['name'], 'cred1')
def test_expand_scanjob(self):
"""Test view expand_scanjob."""
scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_INSPECT)
scan_job.save()
scan_job.sources.add(self.source)
# Job in created state
self.assertEqual(scan_job.status, ScanTask.CREATED)
tasks = scan_job.tasks.all()
self.assertEqual(len(tasks), 0)
# Queue job to run
scan_job.queue()
task = scan_job.tasks.all()[1]
task.systems_count = 2
task.systems_failed = 1
task.systems_scanned = 1
task.save()
scan_job = ScanJob.objects.filter(pk=scan_job.id).first()
json_scan = {'tasks': [{}]}
expand_scanjob(scan_job, json_scan)
self.assertEqual(json_scan.get('systems_count'), 2)
self.assertEqual(json_scan.get('systems_failed'), 1)
self.assertEqual(json_scan.get('systems_scanned'), 1)
def test_queue_task(self):
"""Test create queue state change."""
scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_INSPECT)
scan_job.save()
scan_job.sources.add(self.source)
# Job in created state
self.assertEqual(scan_job.status, ScanTask.CREATED)
tasks = scan_job.tasks.all()
self.assertEqual(len(tasks), 0)
# Queue job to run
scan_job.queue()
# Job should be in pending state
self.assertEqual(scan_job.status, ScanTask.PENDING)
# Queue should have created scan tasks
tasks = scan_job.tasks.all()
self.assertEqual(len(tasks), 2)
# Validate connect task created and correct
connect_task = tasks[0]
self.assertEqual(connect_task.scan_type, ScanTask.SCAN_TYPE_CONNECT)
self.assertEqual(connect_task.status, ScanTask.PENDING)
# Validate inspect task created and correct
inspect_task = tasks[1]
self.assertEqual(inspect_task.scan_type, ScanTask.SCAN_TYPE_INSPECT)
self.assertEqual(inspect_task.status, ScanTask.PENDING)
def create(self, request, *args, **kwargs):
"""Create a details report."""
# pylint: disable=unused-argument
# Validate incoming request body
has_errors, validation_result = validate_details_report_json(
request.data)
if has_errors:
return Response(validation_result,
status=status.HTTP_400_BAD_REQUEST)
# Create FC model and save data
details_report = create_details_report(request.data)
scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_FINGERPRINT,
details_report=details_report)
scan_job.save()
scan_job.queue()
runner = ScanJobRunner(scan_job)
runner.run()
if scan_job.status != ScanTask.COMPLETED:
# pylint: disable=no-member
error_json = {'error': scan_job.tasks.first().status_message}
return Response(error_json, status=status.HTTP_400_BAD_REQUEST)
scan_job = ScanJob.objects.get(pk=scan_job.id)
details_report = DetailsReport.objects.get(pk=details_report.id)
# Prepare REST response body
serializer = self.get_serializer(details_report)
result = serializer.data
return Response(result, status=status.HTTP_201_CREATED)
def sync_merge_reports(request):
"""Merge reports synchronously."""
# pylint: disable=too-many-locals
error = {'reports': []}
details_report_json = _convert_ids_to_json(request.data)
has_errors, validation_result = validate_details_report_json(
details_report_json, True)
if has_errors:
message = _(messages.REPORT_MERGE_NO_RESULTS % validation_result)
error.get('reports').append(message)
raise ValidationError(error)
# Create FC model and save data
details_report_json = _reconcile_source_versions(details_report_json)
report_version = details_report_json.get('report_version', None)
details_report = create_details_report(report_version, details_report_json)
merge_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_FINGERPRINT,
details_report=details_report)
merge_job.save()
merge_job.queue()
runner = ScanJobRunner(merge_job)
runner.run()
if merge_job.status != ScanTask.COMPLETED:
raise Exception(merge_job.status_message)
merge_job.refresh_from_db()
details_report = DetailsReport.objects.get(pk=details_report.id)
# Prepare REST response body
serializer = DetailsReportSerializer(details_report)
result = serializer.data
return Response(result, status=status.HTTP_201_CREATED)
def test_expand_inspect_results(self):
"""Test view expand_inspect_results."""
scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_INSPECT)
scan_job.save()
scan_job.sources.add(self.source)
# Job in created state
self.assertEqual(scan_job.status, ScanTask.CREATED)
tasks = scan_job.tasks.all()
self.assertEqual(len(tasks), 0)
# Queue job to run
scan_job.queue()
inspect_task = scan_job.tasks.all()[1]
inspect_results = JobInspectionResult()
inspect_results.save()
scan_job.inspection_results = inspect_results
scan_job.save()
inspect_result = TaskInspectionResult(source=inspect_task.source,
scan_task=inspect_task)
inspect_result.save()
inspect_results.results.add(inspect_result)
inspect_results.save()
sys_result = SystemInspectionResult(
name='Foo', status=SystemConnectionResult.SUCCESS)
sys_result.save()
fact = RawFact(name='foo', value='"value"')
fact.save()
sys_result.facts.add(fact)
sys_result.save()
inspect_result.systems.add(sys_result)
inspect_result.save()
inspect_results_json = {'results': [{}]}
expand_inspect_results(inspect_results, inspect_results_json)
self.assertEqual(
inspect_results_json['results'][0]['systems'][0]['facts'][0]
['name'], 'foo')
def test_queue_task(self):
"""Test create queue state change."""
# Cannot use util because its testing queue
# Create scan configuration
scan = Scan(name='test',
scan_type=ScanTask.SCAN_TYPE_INSPECT)
scan.save()
# Add source to scan
scan.sources.add(self.source)
options_to_use = ScanOptions()
options_to_use.save()
scan.options = options_to_use
scan.save()
# Create Job
scan_job = ScanJob(scan=scan)
scan_job.save()
# Job in created state
self.assertEqual(scan_job.status, ScanTask.CREATED)
tasks = scan_job.tasks.all()
self.assertEqual(len(tasks), 0)
# Queue job to run
scan_job.queue()
# Job should be in pending state
self.assertEqual(scan_job.status, ScanTask.PENDING)
# Queue should have created scan tasks
tasks = scan_job.tasks.all()
self.assertEqual(len(tasks), 2)
# Validate connect task created and correct
connect_task = tasks[0]
self.assertEqual(connect_task.scan_type, ScanTask.SCAN_TYPE_CONNECT)
self.assertEqual(connect_task.status, ScanTask.PENDING)
# Validate inspect task created and correct
inspect_task = tasks[1]
self.assertEqual(inspect_task.scan_type, ScanTask.SCAN_TYPE_INSPECT)
self.assertEqual(inspect_task.status, ScanTask.PENDING)
def test_start_task(self, start_scan):
"""Test start pending task."""
scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_CONNECT)
scan_job.save()
scan_job.sources.add(self.source)
# Job in created state
tasks = scan_job.tasks.all()
# Queue job to run
scan_job.queue()
self.assertEqual(scan_job.status, ScanTask.PENDING)
# Queue should have created scan tasks
tasks = scan_job.tasks.all()
self.assertEqual(len(tasks), 1)
# Start job
scan_job.start()
def create(self, request, *args, **kwargs):
"""Create a details report."""
# pylint: disable=unused-argument
# Validate incoming request body
has_errors, validation_result = validate_details_report_json(
request.data, True)
if has_errors:
return Response(validation_result,
status=status.HTTP_400_BAD_REQUEST)
report_version = request.data.get('report_version', None)
warn_deprecated = False
if not report_version:
warn_deprecated = True
report_version = create_report_version()
# Create FC model and save data
details_report = create_details_report(create_report_version(),
request.data)
scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_FINGERPRINT,
details_report=details_report)
scan_job.save()
if warn_deprecated:
scan_job.log_message(_(messages.FC_MISSING_REPORT_VERSION),
log_level=logging.WARNING)
scan_job.queue()
runner = ScanJobRunner(scan_job)
runner.run()
if scan_job.status != ScanTask.COMPLETED:
# pylint: disable=no-member
error_json = {'error': scan_job.tasks.first().status_message}
return Response(error_json, status=status.HTTP_400_BAD_REQUEST)
scan_job = ScanJob.objects.get(pk=scan_job.id)
details_report = DetailsReport.objects.get(pk=details_report.id)
# Prepare REST response body
serializer = self.get_serializer(details_report)
result = serializer.data
return Response(result, status=status.HTTP_201_CREATED)
def create_scan_job_two_tasks(source,
source2,
scan_type=ScanTask.SCAN_TYPE_CONNECT,
scan_name='test',
scan_options=None):
"""Create a new scan job with two sources.
:param source: the source for the scan job
:param sourc2: the second source for the scan job
:param scan_type: Either connect or inspect
:param scan_options: Job scan options
:return: the scan job and task
"""
# Create scan configuration
scan = Scan(name=scan_name, scan_type=scan_type)
scan.save()
# Add source to scan
if source is not None:
scan.sources.add(source)
if source2 is not None:
scan.sources.add(source2)
# Add options to scan
if scan_options is not None:
scan.options = scan_options
scan.save()
# Create Job
scan_job = ScanJob(scan=scan)
scan_job.save()
scan_job.queue()
# grab the scan tasks
scan_tasks = scan_job.tasks.all()
if scan_type == ScanTask.SCAN_TYPE_INSPECT:
for task in scan_tasks:
task.complete()
return scan_job, scan_tasks
def test_expand_conn_results(self):
"""Test view expand_conn_results."""
scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_CONNECT)
scan_job.save()
scan_job.sources.add(self.source)
# Job in created state
self.assertEqual(scan_job.status, ScanTask.CREATED)
tasks = scan_job.tasks.all()
self.assertEqual(len(tasks), 0)
# Queue job to run
scan_job.queue()
conn_task = scan_job.tasks.first()
conn_results = JobConnectionResult()
conn_results.save()
scan_job.connection_results = conn_results
scan_job.save()
conn_result = TaskConnectionResult(source=conn_task.source,
scan_task=conn_task)
conn_result.save()
conn_results.results.add(conn_result)
conn_results.save()
sys_result = SystemConnectionResult(
name='Foo',
credential=self.cred,
status=SystemConnectionResult.SUCCESS)
sys_result.save()
conn_result.systems.add(sys_result)
conn_result.save()
conn_results_json = {'results': [{}]}
expand_conn_results(conn_results, conn_results_json)
self.assertEqual(conn_results_json['results'][0]['systems'][0]['name'],
'Foo')
def create_scan_job(source,
scan_type=ScanTask.SCAN_TYPE_CONNECT,
scan_name='test',
scan_options=None):
"""Create a new scan job.
:param source: the source for the scan job
:param scan_type: Either connect or inspect
:param scan_options: Job scan options
:return: the scan job and task
"""
# Create scan configuration
scan = Scan(name=scan_name, scan_type=scan_type)
scan.save()
# Add source to scan
if source is not None:
scan.sources.add(source)
# Add options to scan
if scan_options is not None:
scan.options = scan_options
scan.save()
# Create Job
scan_job = ScanJob(scan=scan)
scan_job.save()
scan_job.queue()
# pylint: disable=no-member
scan_task = scan_job.tasks.first()
if scan_type == ScanTask.SCAN_TYPE_INSPECT:
scan_task.complete()
scan_task = scan_job.tasks.filter(
scan_type=ScanTask.SCAN_TYPE_INSPECT).first()
return scan_job, scan_task
def sync_merge_reports(request):
"""Merge reports synchronously."""
error = {
'reports': []
}
reports = validate_merge_report(request.data)
sources = []
for report in reports:
sources = sources + report.get_sources()
details_report_json = {'sources': sources}
has_errors, validation_result = validate_details_report_json(
details_report_json)
if has_errors:
message = _(messages.REPORT_MERGE_NO_RESULTS % validation_result)
error.get('reports').append(message)
raise ValidationError(error)
# Create FC model and save data
details_report = create_details_report(details_report_json)
scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_FINGERPRINT,
details_report=details_report)
scan_job.save()
scan_job.queue()
runner = ScanJobRunner(scan_job)
runner.run()
if scan_job.status != ScanTask.COMPLETED:
raise Exception(scan_job.status_message)
scan_job = ScanJob.objects.get(pk=scan_job.id)
details_report = DetailsReport.objects.get(pk=details_report.id)
# Prepare REST response body
serializer = DetailsReportSerializer(details_report)
result = serializer.data
return Response(result, status=status.HTTP_201_CREATED)
def test_pause_restart_task(self, start_scan):
"""Test pause and restart task."""
scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_CONNECT)
scan_job.save()
scan_job.sources.add(self.source)
# Job in created state
tasks = scan_job.tasks.all()
# Queue job to run
scan_job.queue()
self.assertEqual(scan_job.status, ScanTask.PENDING)
# Queue should have created scan tasks
tasks = scan_job.tasks.all()
self.assertEqual(len(tasks), 1)
connect_task = scan_job.tasks.first()
self.assertEqual(connect_task.status, ScanTask.PENDING)
# Start job
scan_job.start()
self.assertEqual(scan_job.status, ScanTask.RUNNING)
scan_job.pause()
connect_task = scan_job.tasks.first()
self.assertEqual(scan_job.status, ScanTask.PAUSED)
self.assertEqual(connect_task.status, ScanTask.PAUSED)
scan_job.restart()
connect_task = scan_job.tasks.first()
self.assertEqual(scan_job.status, ScanTask.RUNNING)
self.assertEqual(connect_task.status, ScanTask.PENDING)
scan_job.cancel()
connect_task = scan_job.tasks.first()
self.assertEqual(scan_job.status, ScanTask.CANCELED)
self.assertEqual(connect_task.status, ScanTask.CANCELED)
def test_expand_scanjob(self):
"""Test view expand_scanjob."""
scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_INSPECT)
scan_job.save()
scan_job.sources.add(self.source)
# Job in created state
self.assertEqual(scan_job.status, ScanTask.CREATED)
tasks = scan_job.tasks.all()
self.assertEqual(len(tasks), 0)
# Queue job to run
scan_job.queue()
task = scan_job.tasks.all()[1]
task.update_stats('TEST_VC.', sys_count=2, sys_failed=1, sys_scanned=1)
scan_job = ScanJob.objects.filter(pk=scan_job.id).first()
serializer = ScanJobSerializer(scan_job)
json_scan = serializer.data
expand_scanjob(json_scan)
self.assertEqual(json_scan.get('systems_count'), 2)
self.assertEqual(json_scan.get('systems_failed'), 1)
self.assertEqual(json_scan.get('systems_scanned'), 1)
def test_queue_invalid_state_changes(self):
"""Test create queue failed."""
scan_job = ScanJob(status=ScanTask.FAILED,
scan_type=ScanTask.SCAN_TYPE_INSPECT)
scan_job.save()
scan_job.sources.add(self.source)
# Queue job to run
scan_job.queue()
self.assertEqual(scan_job.status, ScanTask.FAILED)
scan_job.complete()
self.assertEqual(scan_job.status, ScanTask.FAILED)
scan_job.pause()
self.assertEqual(scan_job.status, ScanTask.FAILED)
scan_job.start()
self.assertEqual(scan_job.status, ScanTask.FAILED)
scan_job.cancel()
self.assertEqual(scan_job.status, ScanTask.FAILED)
scan_job.restart()
self.assertEqual(scan_job.status, ScanTask.FAILED)
scan_job.fail()
self.assertEqual(scan_job.status, ScanTask.FAILED)
scan_job.status = ScanTask.CREATED
scan_job.fail()
self.assertEqual(scan_job.status, ScanTask.CREATED)
scan_job.status = ScanTask.RUNNING
scan_job.complete()
self.assertEqual(scan_job.status, ScanTask.COMPLETED)
def test_details(self, start_scan):
"""Get ScanJob result details by primary key."""
scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_INSPECT)
scan_job.save()
scan_job.sources.add(self.source)
# Job in created state
self.assertEqual(scan_job.status, ScanTask.CREATED)
tasks = scan_job.tasks.all()
self.assertEqual(len(tasks), 0)
# Queue job to run
scan_job.queue()
conn_task = scan_job.tasks.first()
conn_results = ConnectionResults(scan_job=scan_job)
conn_results.save()
conn_result = ConnectionResult(source=conn_task.source,
scan_task=conn_task)
conn_result.save()
conn_results.results.add(conn_result)
conn_results.save()
sys_result = SystemConnectionResult(
name='Foo',
credential=self.cred,
status=SystemConnectionResult.SUCCESS)
sys_result.save()
conn_result.systems.add(sys_result)
conn_result.save()
inspect_task = scan_job.tasks.all()[1]
inspect_results = InspectionResults(scan_job=scan_job)
inspect_results.save()
inspect_result = InspectionResult(source=inspect_task.source,
scan_task=inspect_task)
inspect_result.save()
inspect_results.results.add(inspect_result)
inspect_results.save()
sys_result = SystemInspectionResult(
name='Foo', status=SystemConnectionResult.SUCCESS)
sys_result.save()
fact = RawFact(name='foo', value='value')
fact.save()
sys_result.facts.add(fact)
sys_result.save()
inspect_result.systems.add(sys_result)
inspect_result.save()
url = reverse('scanjob-detail', args=(scan_job.id, )) + 'results/'
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
json_response = response.json()
self.assertIn('connection_results', json_response)
self.assertIn('inspection_results', json_response)
self.assertEqual(
json_response, {
'connection_results': {
'scan_job': 1,
'results': []
},
'inspection_results': {
'scan_job': 1,
'results': []
}
})