def setUp(self):
"""Create test case setup."""
self.cred = Credential(
name='cred1',
username='******',
password='******',
become_password=None,
ssh_keyfile=None)
self.cred.save()
options = SourceOptions(disable_ssl=True)
options.save()
self.source = Source(
name='source1',
port=22,
hosts='["1.2.3.4"]')
self.source.options = options
self.source.save()
self.source.credentials.add(self.cred)
self.scan_task = ScanTask(scan_type=ScanTask.SCAN_TYPE_INSPECT,
source=self.source, sequence_number=2)
self.scan_task.save()
self.scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_INSPECT)
self.scan_job.save()
self.scan_job.tasks.add(self.scan_task)
self.conn_results = JobConnectionResult()
self.conn_results.save()
self.scan_job.connection_results = self.conn_results
self.scan_job.save()
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
cred_type=Credential.SATELLITE_CRED_TYPE,
username='******',
password='******',
become_password=None,
become_method=None,
become_user=None,
ssh_keyfile=None)
self.cred.save()
self.source = Source(name='source1', port=443, hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.scan_job, self.scan_task = create_scan_job(
self.source, ScanTask.SCAN_TYPE_INSPECT)
self.api = SatelliteFive(self.scan_job, self.scan_task)
connection_results = TaskConnectionResult()
connection_results.save()
self.api.connect_scan_task.connection_result = connection_results
self.api.connect_scan_task.connection_result.save()
sys_result = SystemConnectionResult(
name='sys1_1', status=SystemInspectionResult.SUCCESS)
sys_result.save()
self.api.connect_scan_task.connection_result.systems.add(sys_result)
self.api.connect_scan_task.connection_result.save()
self.api.connect_scan_task.save()
def test_delete_with_scans(self):
"""Delete a Source used by a scan."""
cred = Credential(name='cred2', username='******',
password='******')
cred.save()
source = Source(name='cred_source',
source_type=Source.NETWORK_SOURCE_TYPE,
hosts=['1.2.3.4'])
source.save()
source.credentials.add(cred)
source.save()
scan = Scan(name='test_scan',
scan_type=ScanTask.SCAN_TYPE_CONNECT)
scan.save()
scan.sources.add(source)
url = reverse('source-detail', args=(source.id,))
response = self.client.delete(url, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
response_json = response.json()
self.assertEqual(
response_json['detail'],
messages.SOURCE_DELETE_NOT_VALID_W_SCANS)
self.assertEqual(response_json['scans'][0]['name'], 'test_scan')
def setUp(self):
"""Create test case setup."""
self.cred = Credential(
name='cred1',
cred_type=Credential.SATELLITE_CRED_TYPE,
username='******',
password='******',
become_password=None,
become_method=None,
become_user=None,
ssh_keyfile=None)
self.cred.save()
self.source = Source(
name='source1',
port=443,
hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.options = SourceOptions(ssl_cert_verify=False)
self.options.save()
self.source.options = self.options
self.source.save()
self.scan_job, self.scan_task = create_scan_job(
self.source, scan_type=ScanTask.SCAN_TYPE_CONNECT)
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
cred_type=Credential.SATELLITE_CRED_TYPE,
username='******',
password='******',
become_password=None,
become_method=None,
become_user=None,
ssh_keyfile=None)
self.cred.save()
self.source = Source(name='source1', port=443, hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.scan_task = ScanTask(scan_type=ScanTask.SCAN_TYPE_CONNECT,
source=self.source,
sequence_number=1)
self.scan_task.save()
self.scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_CONNECT)
self.scan_job.save()
self.scan_job.tasks.add(self.scan_task)
self.conn_results = JobConnectionResult()
self.conn_results.save()
self.scan_job.connection_results = self.conn_results
self.scan_job.save()
self.conn_result = TaskConnectionResult(scan_task=self.scan_task,
source=self.source)
self.conn_result.save()
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
username='******',
password='******',
sudo_password='******',
ssh_keyfile='keyfile')
self.cred.save()
self.source = Source(name='source1', port=22)
self.source.save()
self.source.credentials.add(self.cred)
self.host = HostRange(host_range='1.2.3.4', source_id=self.source.id)
self.host.save()
self.source.hosts.add(self.host)
self.scan_task = ScanTask(source=self.source,
scan_type=ScanTask.SCAN_TYPE_CONNECT)
self.scan_task.systems_failed = 0
self.scan_task.save()
self.scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_CONNECT)
self.scan_job.save()
self.scan_job.sources.add(self.source)
self.scan_job.tasks.add(self.scan_task)
scan_options = ScanOptions()
scan_options.save()
self.scan_job.options = scan_options
self.scan_job.save()
self.conn_results = ConnectionResults(scan_job=self.scan_job)
self.conn_results.save()
def setUp(self):
"""Create test case setup."""
self.cred = Credential(
name='cred1',
cred_type=Credential.SATELLITE_CRED_TYPE,
username='******',
password='******',
become_password=None,
become_method=None,
become_user=None,
ssh_keyfile=None)
self.cred.save()
self.source = Source(
name='source1',
port=443,
hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.scan_job, self.scan_task = create_scan_job(
self.source, ScanTask.SCAN_TYPE_INSPECT)
self.api = SatelliteFive(self.scan_task)
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
username='******',
password='******',
sudo_password=None,
ssh_keyfile=None)
self.cred.save()
self.source = Source(name='source1', port=22)
self.source.save()
self.source.credentials.add(self.cred)
self.host = HostRange(host_range='1.2.3.4', source_id=self.source.id)
self.host.save()
self.source.hosts.add(self.host)
self.scan_task = ScanTask(scan_type=ScanTask.SCAN_TYPE_INSPECT,
source=self.source,
sequence_number=2)
self.scan_task.save()
self.scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_INSPECT)
self.scan_job.save()
self.scan_job.tasks.add(self.scan_task)
self.conn_results = ConnectionResults(scan_job=self.scan_job)
self.conn_results.save()
def setUp(self):
"""Create test case setup."""
self.cred = Credential(
name='cred1',
username='******',
password='******',
become_password=None,
ssh_keyfile=None)
self.cred.save()
self.source = Source(
name='source1',
port=22,
hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.scan_task = ScanTask(scan_type=ScanTask.SCAN_TYPE_CONNECT,
source=self.source, sequence_number=2,
start_time=datetime.utcnow())
self.scan_task.save()
self.scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_CONNECT)
self.scan_job.save()
self.scan_job.tasks.add(self.scan_task)
self.conn_results = JobConnectionResult()
self.conn_results.save()
self.scan_job.connection_results = self.conn_results
self.scan_job.save()
self.runner = ConnectTaskRunner(scan_job=self.scan_job,
scan_task=self.scan_task)
def test_hostcred_delete_view(self):
"""Tests the delete view set of the Credential API."""
cred = Credential(name='cred2', username='******', password='******')
cred.save()
url = reverse('cred-detail', args=(cred.pk, ))
resp = self.client.delete(url, format='json')
self.assertEqual(resp.status_code, status.HTTP_204_NO_CONTENT)
class SatelliteFactoryTest(TestCase):
"""Tests Satellite factory functions."""
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
cred_type=Credential.SATELLITE_CRED_TYPE,
username='******',
password='******',
become_password=None,
become_method=None,
become_user=None,
ssh_keyfile=None)
self.cred.save()
self.source = Source(name='source1', port=443, hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.scan_job, self.scan_task = create_scan_job(
self.source, scan_type=ScanTask.SCAN_TYPE_CONNECT)
def tearDown(self):
"""Cleanup test case setup."""
pass
def test_create_sat_none(self):
"""Test the method to fail to create a Sat interface."""
satellite_version = None
api_version = 1
api = create(satellite_version, api_version, self.scan_task)
self.assertEqual(api, None)
def test_create_sat5(self):
"""Test the method to create a Sat 5 interface."""
satellite_version = SATELLITE_VERSION_5
api_version = 1
api = create(satellite_version, api_version, self.scan_task)
self.assertEqual(api.__class__, SatelliteFive)
def test_create_sat6_v1(self):
"""Test the method to create a Sat 6 interface."""
satellite_version = SATELLITE_VERSION_6
api_version = 1
api = create(satellite_version, api_version, self.scan_task)
self.assertEqual(api.__class__, SatelliteSixV1)
def test_create_sat6_v2(self):
"""Test the method to create a Sat 6 interface."""
satellite_version = SATELLITE_VERSION_6
api_version = 2
api = create(satellite_version, api_version, self.scan_task)
self.assertEqual(api.__class__, SatelliteSixV2)
def test_create_sat6_unknown(self):
"""Test the method to create a Sat 6 interface."""
satellite_version = SATELLITE_VERSION_6
api_version = 9
api = create(satellite_version, api_version, self.scan_task)
self.assertEqual(api, None)
def setUp(self):
"""Create test case setup."""
self.cred = Credential(
name='cred1',
username='******',
password='******',
ssh_keyfile=None,
become_method=None,
become_user=None,
become_password=None)
self.cred.save()
hc_serializer = CredentialSerializer(self.cred)
self.cred_data = hc_serializer.data
self.source = Source(
name='source1',
port=22,
hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.host_list = [('1.2.3.4', self.cred_data)]
# setup scan options
self.scan_job, self.scan_task = create_scan_job(
self.source,
ScanTask.SCAN_TYPE_INSPECT)
self.connect_scan_task = self.scan_task.prerequisites.first()
self.connect_scan_task.update_stats(
'TEST NETWORK CONNECT.', sys_failed=0)
success_sys = SystemConnectionResult(
name='1.2.3.4', credential=self.cred,
status=SystemConnectionResult.SUCCESS)
success_sys.save()
failed_sys = SystemConnectionResult(
name='1.1.1.2', status=SystemConnectionResult.FAILED)
failed_sys.save()
conn_result = self.connect_scan_task.connection_result
conn_result.systems.add(success_sys)
conn_result.systems.add(failed_sys)
conn_result.save()
self.connect_scan_task.update_stats(
'TEST_VC.', sys_count=2, sys_failed=1, sys_scanned=1)
self.connect_scan_task.complete()
self.scan_task.update_stats(
'TEST NETWORK INSPECT.', sys_failed=0)
self.fact_endpoint = 'http://testserver' + reverse('facts-list')
self.scan_job.save()
scan_data_log.disable_log_for_test()
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
username='******',
password='******',
ssh_keyfile=None,
become_method=None,
become_user=None,
become_password=None)
self.cred.save()
hc_serializer = CredentialSerializer(self.cred)
self.cred_data = hc_serializer.data
# setup source for scan
self.source = Source(name='source1', port=22, hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.host_list = [('1.2.3.4', self.cred_data)]
self.scan_job, self.scan_task = create_scan_job(
self.source, ScanTask.SCAN_TYPE_INSPECT)
self.connect_scan_task = self.scan_task.prerequisites.first()
self.connect_scan_task.update_stats('TEST NETWORK CONNECT.',
sys_failed=0)
conn_result = self.connect_scan_task.connection_result
success_sys = SystemConnectionResult(
name='1.2.3.4',
credential=self.cred,
status=SystemConnectionResult.SUCCESS,
task_connection_result=conn_result)
success_sys.save()
failed_sys = SystemConnectionResult(
name='1.1.1.2',
status=SystemConnectionResult.FAILED,
task_connection_result=conn_result)
failed_sys.save()
conn_result.save()
self.connect_scan_task.update_stats('TEST_VC.',
sys_count=2,
sys_failed=1,
sys_scanned=1)
self.connect_scan_task.complete()
self.scan_task.update_stats('TEST NETWORK INSPECT.', sys_failed=0)
self.fact_endpoint = 'http://testserver' + reverse('reports-list')
self.scan_job.save()
self.stop_states = [
ScanJob.JOB_TERMINATE_CANCEL, ScanJob.JOB_TERMINATE_PAUSE
]
self.interrupt = Mock(value=ScanJob.JOB_RUN)
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
cred_type=Credential.SATELLITE_CRED_TYPE,
username='******',
password='******')
self.cred.save()
self.source = Source(name='source1', port=443, hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
class VCenterUtilsTest(TestCase):
"""Tests VCenter utils functions."""
def setUp(self):
"""Create test case setup."""
self.cred = Credential(
name='cred1',
username='******',
password='******',
become_password=None,
ssh_keyfile=None)
self.cred.save()
options = SourceOptions(disable_ssl=True)
options.save()
self.source = Source(
name='source1',
port=22,
hosts='["1.2.3.4"]')
self.source.options = options
self.source.save()
self.source.credentials.add(self.cred)
self.scan_task = ScanTask(scan_type=ScanTask.SCAN_TYPE_INSPECT,
source=self.source, sequence_number=2)
self.scan_task.save()
self.scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_INSPECT)
self.scan_job.save()
self.scan_job.tasks.add(self.scan_task)
self.conn_results = JobConnectionResult()
self.conn_results.save()
self.scan_job.connection_results = self.conn_results
self.scan_job.save()
def tearDown(self):
"""Cleanup test case setup."""
pass
def test_vcenter_connect(self):
"""Test the connection method."""
mock_vcenter = Mock()
with patch('scanner.vcenter.utils.SmartConnectNoSSL',
return_value=mock_vcenter) as mock_smart_connect:
vcenter = vcenter_connect(self.scan_task)
self.assertEqual(mock_vcenter, vcenter)
mock_smart_connect.assert_called_once_with(
host=ANY, user=ANY, pwd=ANY, port=ANY)
def test_cred_delete_with_source(self):
"""Tests delete when cred used by source."""
cred = Credential(name='cred2', username='******', password='******')
cred.save()
source = Source(name='cred_source',
source_type=Source.NETWORK_SOURCE_TYPE,
hosts=['1.2.3.4'])
source.save()
source.credentials.add(cred)
source.save()
url = reverse('cred-detail', args=(cred.pk, ))
resp = self.client.delete(url, format='json')
self.assertEqual(resp.status_code, status.HTTP_400_BAD_REQUEST)
response_json = resp.json()
self.assertEqual(response_json['detail'],
messages.CRED_DELETE_NOT_VALID_W_SOURCES)
self.assertEqual(response_json['sources'][0]['name'], 'cred_source')
def setUp(self):
"""Create test case setup."""
self.cred = Credential(
name='cred1',
cred_type=Credential.SATELLITE_CRED_TYPE,
username='******',
password='******')
self.cred.save()
self.source = Source(
name='source1',
port=443,
hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.scan_task = ScanTask(scan_type=ScanTask.SCAN_TYPE_INSPECT,
source=self.source, sequence_number=2,
start_time=datetime.utcnow())
self.scan_task.save()
self.scan_task.update_stats('TEST_SAT.', sys_scanned=0)
self.scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_CONNECT)
self.scan_job.save()
self.scan_job.tasks.add(self.scan_task)
self.conn_results = JobConnectionResult()
self.conn_results.save()
self.scan_job.connection_results = self.conn_results
self.conn_result = TaskConnectionResult(
scan_task=self.scan_task, source=self.source)
self.conn_result.save()
conn_task = ScanTask(scan_type=ScanTask.SCAN_TYPE_CONNECT,
source=self.source, sequence_number=1,
start_time=datetime.utcnow())
conn_task.complete()
self.scan_task.prerequisites.add(conn_task)
self.inspect_results = JobInspectionResult()
self.inspect_results.save()
self.scan_job.inspection_results = self.inspect_results
self.scan_job.save()
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
username='******',
password='******',
become_password=None,
ssh_keyfile=None)
self.cred.save()
options = SourceOptions(disable_ssl=True)
options.save()
self.source = Source(name='source1', port=22, hosts='["1.2.3.4"]')
self.source.options = options
self.source.save()
self.source.credentials.add(self.cred)
self.scan_job, self.scan_task = create_scan_job(
self.source, scan_type=ScanTask.SCAN_TYPE_INSPECT)
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
username='******',
password='******',
become_password=None,
ssh_keyfile=None)
self.cred.save()
self.source = Source(name='source1', port=22, hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.scan_job, self.scan_task = create_scan_job(
self.source, ScanTask.SCAN_TYPE_CONNECT)
# Create runner
self.runner = ConnectTaskRunner(scan_job=self.scan_job,
scan_task=self.scan_task)
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
username='******',
password='******',
ssh_keyfile='keyfile',
become_method='sudo',
become_user='******',
become_password='******')
self.cred.save()
self.source = Source(name='source1', port=22)
self.source.save()
self.source.credentials.add(self.cred)
self.source.hosts = '["1.2.3.4"]'
self.source.save()
self.scan_task = ScanTask(source=self.source,
scan_type=ScanTask.SCAN_TYPE_INSPECT)
self.scan_task.save()
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
username='******',
password='******',
sudo_password=None,
ssh_keyfile=None)
self.cred.save()
self.source = Source(name='source1', port=22)
self.source.save()
self.source.credentials.add(self.cred)
self.host = HostRange(host_range='1.2.3.4', source_id=self.source.id)
self.host.save()
self.source.hosts.add(self.host)
self.scan_task = ScanTask(scan_type=ScanTask.SCAN_TYPE_INSPECT,
source=self.source,
sequence_number=2)
self.scan_task.save()
self.conn_task = ScanTask(scan_type=ScanTask.SCAN_TYPE_CONNECT,
source=self.source,
sequence_number=1)
self.conn_task.systems_count = 5
self.conn_task.status = ScanTask.COMPLETED
self.conn_task.save()
self.scan_task.prerequisites.add(self.conn_task)
self.scan_task.save()
self.scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_INSPECT)
self.scan_job.save()
self.scan_job.tasks.add(self.scan_task)
self.inspect_results = InspectionResults(scan_job=self.scan_job)
self.inspect_results.save()
self.runner = InspectTaskRunner(scan_job=self.scan_job,
scan_task=self.scan_task,
inspect_results=self.inspect_results)
def setUp(self):
"""Set up required for tests."""
self.cred = Credential(name='cred1',
username='******',
password='******',
ssh_keyfile='keyfile',
become_method='sudo',
become_user='******',
become_password='******')
self.cred.save()
self.source = Source(name='source1',
hosts='["1.2.3.4", "1.2.3.5", "1.2.3.6"]',
source_type='network',
port=22)
self.source.save()
self.source.credentials.add(self.cred)
self.source.save()
self.scan_job, self.scan_task = create_scan_job(
self.source, ScanTask.SCAN_TYPE_CONNECT)
self.interrupt = Mock(value=ScanJob.JOB_RUN)
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
cred_type=Credential.SATELLITE_CRED_TYPE,
username='******',
password='******',
become_password=None,
become_method=None,
become_user=None,
ssh_keyfile=None)
self.cred.save()
self.source = Source(name='source1', port=443, hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.scan_task = ScanTask(scan_type=ScanTask.SCAN_TYPE_CONNECT,
source=self.source,
sequence_number=1,
start_time=datetime.utcnow())
self.scan_task.save()
self.scan_task.update_stats('TEST_SAT.', sys_scanned=0)
self.scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_CONNECT)
self.scan_job.save()
self.scan_job.tasks.add(self.scan_task)
self.conn_results = JobConnectionResult()
self.conn_results.save()
self.scan_job.connection_results = self.conn_results
self.scan_job.save()
self.conn_result = TaskConnectionResult(scan_task=self.scan_task,
source=self.source)
self.conn_result.save()
self.inspect_result = TaskInspectionResult(scan_task=self.scan_task,
source=self.source)
self.inspect_result.save()
self.api = SatelliteSixV2(self.scan_task, self.conn_result,
self.inspect_result)
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
username='******',
password='******',
ssh_keyfile='keyfile',
become_method='sudo',
become_user='******',
become_password='******')
self.cred.save()
# Source with excluded hosts
self.source = Source(name='source1',
hosts='["1.2.3.4", "1.2.3.5"]',
exclude_hosts='["1.2.3.5", "1.2.3.6"]',
source_type='network',
port=22)
self.source.save()
self.source.credentials.add(self.cred)
self.source.save()
self.scan_job, self.scan_task = create_scan_job(
self.source, ScanTask.SCAN_TYPE_CONNECT)
self.scan_task.update_stats('TEST NETWORK CONNECT.', sys_failed=0)
# Source without excluded hosts
self.source2 = Source(name='source2',
hosts='["1.2.3.4"]',
source_type='network',
port=22)
self.source2.save()
self.source2.credentials.add(self.cred)
self.source2.save()
self.scan_job2, self.scan_task2 = create_scan_job(
self.source, ScanTask.SCAN_TYPE_CONNECT, 'source2')
self.scan_task2.update_stats('TEST NETWORK CONNECT.', sys_failed=0)
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
username='******',
password='******',
ssh_keyfile='keyfile',
become_method='sudo',
become_user='******',
become_password='******')
self.cred.save()
self.source = Source(name='source1', port=22)
self.source.save()
self.source.credentials.add(self.cred)
self.source.hosts = '["1.2.3.4"]'
self.source.save()
self.scan_job, self.scan_task = create_scan_job(
self.source, ScanTask.SCAN_TYPE_CONNECT)
self.scan_task.update_stats('TEST NETWORK CONNECT.', sys_failed=0)
def setUp(self):
"""Create test case setup."""
cred = Credential(name='cred1',
username='******',
password='******',
become_password=None,
ssh_keyfile=None)
cred.save()
source = Source(name='source1', port=22, hosts='["1.2.3.4"]')
source.save()
source.credentials.add(cred)
self.scan_job, self.scan_task = create_scan_job(
source, ScanTask.SCAN_TYPE_INSPECT)
self.connect_scan_task = self.scan_task.prerequisites.first()
self.connect_scan_task.update_stats('TEST_VC.', sys_count=5)
self.connect_scan_task.complete()
# Create task runner
self.runner = InspectTaskRunner(scan_job=self.scan_job,
scan_task=self.scan_task)
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
username='******',
password='******',
ssh_keyfile='keyfile',
become_method='sudo',
become_user='******',
become_password='******')
self.cred.save()
self.source = Source(name='source1', port=22)
self.source.save()
self.source.credentials.add(self.cred)
self.source.hosts = '["1.2.3.4"]'
self.source.save()
self.scan_task = ScanTask(source=self.source,
scan_type=ScanTask.SCAN_TYPE_CONNECT,
start_time=datetime.utcnow())
self.scan_task.update_stats('TEST NETWORK CONNECT.', sys_failed=0)
self.scan_job = ScanJob(scan_type=ScanTask.SCAN_TYPE_CONNECT)
self.scan_job.save()
self.scan_job.sources.add(self.source)
self.scan_job.tasks.add(self.scan_task)
scan_options = ScanOptions()
scan_options.save()
self.scan_job.options = scan_options
self.scan_job.save()
self.conn_results = JobConnectionResult()
self.conn_results.save()
self.scan_job.connection_results = self.conn_results
self.scan_job.save()
class SatelliteSixV2Test(TestCase):
"""Tests Satellite 6 v2 functions."""
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
cred_type=Credential.SATELLITE_CRED_TYPE,
username='******',
password='******',
become_password=None,
become_method=None,
become_user=None,
ssh_keyfile=None)
self.cred.save()
self.source = Source(name='source1', port=443, hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.scan_job, self.scan_task = create_scan_job(
self.source, ScanTask.SCAN_TYPE_INSPECT)
self.scan_task.update_stats('TEST_SAT.', sys_scanned=0)
self.api = SatelliteSixV2(self.scan_job, self.scan_task)
job_conn_result = JobConnectionResult()
job_conn_result.save()
connection_results = TaskConnectionResult(
job_connection_result=job_conn_result)
connection_results.save()
self.api.connect_scan_task.connection_result = connection_results
self.api.connect_scan_task.connection_result.save()
conn_result = self.api.connect_scan_task.connection_result
sys_result = SystemConnectionResult(
name='sys1_1',
status=SystemInspectionResult.SUCCESS,
task_connection_result=conn_result)
sys_result.save()
self.api.connect_scan_task.save()
def tearDown(self):
"""Cleanup test case setup."""
pass
def test_host_count(self):
"""Test the method host_count."""
hosts_url = 'https://{sat_host}:{port}/api/v2/hosts'
with requests_mock.Mocker() as mocker:
url = construct_url(url=hosts_url, sat_host='1.2.3.4', org_id=1)
jsonresult = {
'results': [{
'name': 'sys1'
}, {
'name': 'sys2'
}, {
'name': 'sys3'
}],
'per_page': 100,
'total': 3
}
mocker.get(url, status_code=200, json=jsonresult)
systems_count = self.api.host_count()
self.assertEqual(systems_count, 3)
def test_host_count_with_err(self):
"""Test the method host_count with error."""
hosts_url = 'https://{sat_host}:{port}/api/v2/hosts'
with requests_mock.Mocker() as mocker:
url = construct_url(url=hosts_url, sat_host='1.2.3.4', org_id=1)
jsonresult = {
'results': [{
'name': 'sys1'
}, {
'name': 'sys2'
}, {
'name': 'sys3'
}],
'per_page': 100,
'total': 3
}
mocker.get(url, status_code=500, json=jsonresult)
with self.assertRaises(SatelliteException):
self.api.host_count()
def test_hosts(self):
"""Test the method hosts."""
hosts_url = 'https://{sat_host}:{port}/api/v2/hosts'
with requests_mock.Mocker() as mocker:
url = construct_url(url=hosts_url, sat_host='1.2.3.4', org_id=1)
jsonresult = {
'results': [{
'name': 'sys1',
'id': 1
}, {
'name': 'sys2',
'id': 2
}, {
'name': 'sys3',
'id': 3
}],
'per_page':
100,
'total':
3
}
mocker.get(url, status_code=200, json=jsonresult)
systems_count = self.api.host_count()
hosts = self.api.hosts()
self.assertEqual(systems_count, 3)
self.assertEqual(len(hosts), 3)
self.assertEqual(hosts, ['sys1_1', 'sys2_2', 'sys3_3'])
def test_hosts_with_err(self):
"""Test the method hosts with error."""
hosts_url = 'https://{sat_host}:{port}/api/v2/hosts'
with requests_mock.Mocker() as mocker:
url = construct_url(url=hosts_url, sat_host='1.2.3.4', org_id=1)
jsonresult = {
'results': [{
'name': 'sys1'
}, {
'name': 'sys2'
}, {
'name': 'sys3'
}],
'per_page': 100,
'total': 3
}
mocker.get(url, status_code=500, json=jsonresult)
with self.assertRaises(SatelliteException):
self.api.hosts()
def test_processing_fields_with_err(self):
"""Test the post_processing with error."""
host_field_url = 'https://{sat_host}:{port}/api/v2/hosts/{host_id}'
with requests_mock.Mocker() as mocker:
url = construct_url(url=host_field_url,
sat_host='1.2.3.4',
host_id=1)
mocker.get(url, status_code=500)
result = request_host_details(
self.scan_task, {
'job_id': self.scan_job.id,
'task_sequence_number': self.scan_task.id,
'scan_type': self.scan_task.scan_type,
'source_type': self.scan_task.source.source_type,
'source_name': self.scan_task.source.name
}, 1, 'sys', url, url, {})
expected = {
'unique_name': 'sys_1',
'system_inspection_result': 'failed',
'host_fields_response': {},
'host_subscriptions_response': {}
}
self.assertEqual(result, expected)
process_results(self.api, [result], 1)
inspect_results = self.scan_task.inspection_result.systems.all()
sys_1_result = inspect_results.filter(name='sys_1').first()
self.assertEqual(sys_1_result.name, 'sys_1')
self.assertEqual(sys_1_result.status, 'failed')
def test_host_fields(self):
"""Test the method host_fields."""
host_field_url = 'https://{sat_host}:{port}/api/v2/hosts/{host_id}'
with requests_mock.Mocker() as mocker:
url = construct_url(url=host_field_url,
sat_host='1.2.3.4',
host_id=1)
jsonresult = {
'architecture_id': 1,
'architecture_name': 'x86_64',
'operatingsystem_name': 'RedHat 7.4',
'uuid': None,
'created_at': '2017-12-04 13:19:57 UTC',
'updated_at': '2017-12-04 13:21:47 UTC',
'organization_name': 'ACME',
'location_name': 'Raleigh',
'name': 'mac52540071bafe.prov.lan',
'virtual_host': {
'uuid': '100',
'name': 'vhost1'
},
'virtual_guests': [{
'name': 'foo'
}],
'content_facet_attributes': {
'id': 11,
'katello_agent_installed': False
},
'subscription_facet_attributes': {
'uuid': '00c7a108-48ec-4a97-835c-aa3369777f64',
'last_checkin': '2018-01-04 17:36:07 UTC',
'registered_at': '2017-12-04 13:33:52 UTC',
'registered_by': 'sat-r220-07.lab.eng.rdu2.redhat.com',
'virtual_host': {
'uuid': '100',
'name': 'vhost1'
},
'virtual_guests': [{
'name': 'foo'
}],
},
'facts': {
'memorysize_mb': '992.45',
'memorysize': '992.45 MB',
'hostname': 'fdi',
'type': 'Other',
'architecture': 'x86_64',
'is_virtual': 'true',
'virtual': 'kvm',
'net::interface::ipv4_address': '192.168.99.123',
'net::interface::mac_address': 'fe80::5054:ff:fe24:946e',
},
}
mocker.get(url, status_code=200, json=jsonresult)
host_info = host_fields(2, jsonresult)
expected = {
'uuid': '00c7a108-48ec-4a97-835c-aa3369777f64',
'hostname': 'mac52540071bafe.prov.lan',
'registered_by': 'sat-r220-07.lab.eng.rdu2.redhat.com',
'registration_time': '2017-12-04 13:33:52 UTC',
'last_checkin_time': '2018-01-04 17:36:07 UTC',
'katello_agent_installed': False,
'os_release': 'RedHat 7.4',
'organization': 'ACME',
'virtual_host_uuid': '100',
'virtual_host_name': 'vhost1',
'virt_type': None,
'kernel_version': None,
'architecture': None,
'is_virtualized': None,
'cores': None,
'num_sockets': None,
'num_virtual_guests': 1,
'virtual': 'hypervisor',
'location': 'Raleigh',
'ip_addresses': ['192.168.99.123'],
'mac_addresses': ['fe80::5054:ff:fe24:946e'],
'os_name': 'RedHat',
'os_version': '7.4'
}
self.assertEqual(host_info, expected)
def test_get_https_with_err(self):
"""Test the host subscriptons method with bad status code."""
sub_url = 'https://{sat_host}:{port}/' \
'api/v2/hosts/{host_id}/subscriptions'
with requests_mock.Mocker() as mocker:
url = construct_url(url=sub_url, sat_host='1.2.3.4', host_id=1)
mocker.get(url, status_code=500)
result = request_host_details(
self.scan_task, {
'job_id': self.scan_job.id,
'task_sequence_number': self.scan_task.id,
'scan_type': self.scan_task.scan_type,
'source_type': self.scan_task.source.source_type,
'source_name': self.scan_task.source.name
}, 1, 'sys', url, url, {})
expected = {
'unique_name': 'sys_1',
'system_inspection_result': 'failed',
'host_fields_response': {},
'host_subscriptions_response': {}
}
self.assertEqual(result, expected)
def test_processing_subs_err_nojson(self):
"""Test the flow of post processing with bad code and not json."""
sub_url = 'https://{sat_host}:{port}/' \
'api/v2/hosts/{host_id}/subscriptions'
with requests_mock.Mocker() as mocker:
url = construct_url(url=sub_url, sat_host='1.2.3.4', host_id=1)
mocker.get(url, status_code=404, text='error message')
result = request_host_details(
self.scan_task, {
'job_id': self.scan_job.id,
'task_sequence_number': self.scan_task.id,
'scan_type': self.scan_task.scan_type,
'source_type': self.scan_task.source.source_type,
'source_name': self.scan_task.source.name
}, 1, 'sys', url, url, {})
process_results(self.api, [result], 1)
inspect_results = self.scan_task.inspection_result.systems.all()
sys_1_result = inspect_results.filter(name='sys_1').first()
self.assertEqual(sys_1_result.name, 'sys_1')
self.assertEqual(sys_1_result.status, 'failed')
def test_host_not_subscribed(self):
"""Test the host subscriptons method for not subscribed error."""
sub_url = 'https://{sat_host}:{port}/' \
'api/v2/hosts/{host_id}/subscriptions'
with requests_mock.Mocker() as mocker:
url = construct_url(url=sub_url, sat_host='1.2.3.4', host_id=1)
err_msg = {
'displayMessage':
'Host has not been registered '
'with subscription-manager',
'errors':
['Host has not been registered'
' with subscription-manager']
} # noqa
mocker.get(url, status_code=400, json=err_msg)
result = request_host_details(
self.scan_task, {
'job_id': self.scan_job.id,
'task_sequence_number': self.scan_task.id,
'scan_type': self.scan_task.scan_type,
'source_type': self.scan_task.source.source_type,
'source_name': self.scan_task.source.name
}, 1, 'sys', url, url, {})
process_results(self.api, [result], 1)
inspect_results = self.scan_task.inspection_result.systems.all()
sys_1_result = inspect_results.filter(name='sys_1').first()
self.assertEqual(sys_1_result.name, 'sys_1')
self.assertEqual(sys_1_result.status, 'failed')
def test_host_subscriptons(self):
"""Test the host subscriptons method."""
sub_url = 'https://{sat_host}:{port}/' \
'api/v2/hosts/{host_id}/subscriptions'
with requests_mock.Mocker() as mocker:
url = construct_url(url=sub_url, sat_host='1.2.3.4', host_id=1)
jsonresult = {
'results': [{
'amount': 1,
'name': 'Satellite Tools 6.3',
'start_date': '2017-12-01 14:50:59 UTC',
'end_date': '2047-11-24 14:50:59 UTC',
'product_name': 'Satellite Tools 6.3',
}, {
'quantity_consumed': 1,
'name': 'Employee SKU',
'start_date': '2016-03-24 04:00:00 UTC',
'end_date': '2022-01-01 04:59:59 UTC',
'account_number': 1212729,
'contract_number': 10913844,
'type': 'ENTITLEMENT_DERIVED',
'product_name': 'Employee SKU',
}]
}
mocker.get(url, status_code=200, json=jsonresult)
subs = host_subscriptions(jsonresult)
expected = {
'entitlements': [{
'derived_entitlement': False,
'name': 'Satellite Tools 6.3',
'amount': 1,
'account_number': None,
'contract_number': None,
'start_date': '2017-12-01 14:50:59 UTC',
'end_date': '2047-11-24 14:50:59 UTC'
}, {
'derived_entitlement': True,
'name': 'Employee SKU',
'amount': 1,
'account_number': 1212729,
'contract_number': 10913844,
'start_date': '2016-03-24 04:00:00 UTC',
'end_date': '2022-01-01 04:59:59 UTC'
}]
}
self.assertEqual(subs, expected)
def test_post_processing_err(self):
"""Test error flow & check that a failed system is marked."""
response = {
'unique_name': 'sys_1',
'system_inspection_result': SystemInspectionResult.FAILED,
'host_fields_response': {},
'host_subscriptions_response': {}
}
process_results(self.api, [response], 1)
inspect_results = self.scan_task.inspection_result.systems.all()
sys_1_result = inspect_results.filter(name='sys_1').first()
self.assertEqual(sys_1_result.name, 'sys_1')
self.assertEqual(sys_1_result.status, 'failed')
def test_post_processing(self):
"""Test process_results method with mock data."""
fields_return_value = {
'uuid': '00c7a108-48ec-4a97-835c-aa3369777f64',
'hostname': 'mac52540071bafe.prov.lan',
'registered_by': 'sat-r220-07.lab.eng.rdu2.redhat.com',
'registration_time': '2017-12-04 13:33:52 UTC',
'last_checkin_time': '2018-01-04 17:36:07 UTC',
'katello_agent_installed': False,
'os_name': 'RedHat 7.4',
'organization': 'ACME',
'virtual_host_uuid': '100',
'virtual_host_name': 'vhost1',
'virt_type': None,
'kernel_version': None,
'architecture': None,
'is_virtualized': None,
'cores': None,
'num_sockets': None,
'num_virtual_guests': 1,
'virtual': 'hypervisor',
'location': 'Raleigh',
'ip_addresses': ['192.168.99.123'],
'ipv6_addresses': ['fe80::5054:ff:fe24:946e']
}
subs_return_value = {
'entitlements': [{
'derived_entitlement': False,
'name': 'Satellite Tools 6.3',
'amount': 1,
'account_number': None,
'contract_number': None,
'start_date': '2017-12-01 14:50:59 UTC',
'end_date': '2047-11-24 14:50:59 UTC'
}, {
'derived_entitlement': True,
'name': 'Employee SKU',
'amount': 1,
'account_number': 1212729,
'contract_number': 10913844,
'start_date': '2016-03-24 04:00:00 UTC',
'end_date': '2022-01-01 04:59:59 UTC'
}]
}
expected = {
'uuid':
'00c7a108-48ec-4a97-835c-aa3369777f64',
'hostname':
'mac52540071bafe.prov.lan',
'registered_by':
'sat-r220-07.lab.eng.rdu2.redhat.com',
'registration_time':
'2017-12-04 13:33:52 UTC',
'last_checkin_time':
'2018-01-04 17:36:07 UTC',
'katello_agent_installed':
False,
'os_name':
'RedHat 7.4',
'organization':
'ACME',
'virtual_host_uuid':
'100',
'virtual_host_name':
'vhost1',
'num_virtual_guests':
1,
'virtual':
'hypervisor',
'location':
'Raleigh',
'ip_addresses': ['192.168.99.123'],
'ipv6_addresses': ['fe80::5054:ff:fe24:946e'],
'entitlements': [{
'derived_entitlement': False,
'name': 'Satellite Tools 6.3',
'amount': 1,
'account_number': None,
'contract_number': None,
'start_date': '2017-12-01 14:50:59 UTC',
'end_date': '2047-11-24 14:50:59 UTC'
}, {
'derived_entitlement': True,
'name': 'Employee SKU',
'amount': 1,
'account_number': 1212729,
'contract_number': 10913844,
'start_date': '2016-03-24 04:00:00 UTC',
'end_date': '2022-01-01 04:59:59 UTC'
}]
}
with patch('scanner.satellite.six.host_fields',
return_value=fields_return_value) as mock_fields:
with patch('scanner.satellite.six.host_subscriptions',
return_value=subs_return_value) as mock_subs:
result = {
'unique_name': 'sys_1',
'system_inspection_result': SystemInspectionResult.SUCCESS,
'host_fields_response': fields_return_value,
'host_subscriptions_response': subs_return_value
}
process_results(self.api, [result], 1)
inspect_results = \
self.scan_task.inspection_result.systems.all()
sys_1_result = inspect_results.filter(name='sys_1').first()
self.assertEqual(sys_1_result.name, 'sys_1')
self.assertEqual(sys_1_result.status, 'success')
result = {}
for fact in sys_1_result.facts.all():
result[fact.name] = json.loads(fact.value)
self.assertEqual(result, expected)
mock_fields.assert_called_once_with(ANY, ANY)
mock_subs.assert_called_once_with(ANY)
mock_fields.assert_called_once_with(ANY, ANY)
mock_subs.assert_called_once_with(ANY)
def test_hosts_facts_with_err(self):
"""Test the hosts_facts method."""
hosts_url = 'https://{sat_host}:{port}/api/v2/hosts'
with requests_mock.Mocker() as mocker:
url = construct_url(url=hosts_url, sat_host='1.2.3.4')
mocker.get(url, status_code=500)
with self.assertRaises(SatelliteException):
self.api.hosts_facts(Value('i', ScanJob.JOB_RUN))
@patch('multiprocessing.pool.Pool.starmap',
return_value=[{
'unique_name': 'sys_1',
'system_inspection_result': 'success',
'host_fields_response': {},
'host_subscriptions_response': {}
}])
def test_hosts_facts(self, mock_pool):
"""Test the hosts_facts method."""
scan_options = ScanOptions(max_concurrency=10)
scan_options.save()
scan_job, scan_task = create_scan_job(self.source,
ScanTask.SCAN_TYPE_INSPECT,
scan_name='test_62',
scan_options=scan_options)
scan_task.update_stats('TEST_SAT.', sys_scanned=0)
api = SatelliteSixV2(scan_job, scan_task)
job_conn_result = JobConnectionResult()
job_conn_result.save()
connection_results = TaskConnectionResult(
job_connection_result=job_conn_result)
connection_results.save()
api.connect_scan_task.connection_result = connection_results
api.connect_scan_task.connection_result.save()
sys_result = SystemConnectionResult(
name='sys1_1',
status=SystemInspectionResult.SUCCESS,
task_connection_result=api.connect_scan_task.connection_result)
sys_result.save()
api.connect_scan_task.save()
hosts_url = 'https://{sat_host}:{port}/api/v2/hosts'
with requests_mock.Mocker() as mocker:
url = construct_url(url=hosts_url, sat_host='1.2.3.4')
jsonresult = {
'total': 1,
'subtotal': 1,
'page': 1,
'per_page': 100,
'results': [{
'id': 10,
'name': 'sys10'
}]
} # noqa
mocker.get(url, status_code=200, json=jsonresult)
api.hosts_facts(Value('i', ScanJob.JOB_RUN))
inspect_result = scan_task.inspection_result
self.assertEqual(len(inspect_result.systems.all()), 1)
class SatelliteFiveTest(TestCase):
"""Tests Satellite 5 functions."""
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
cred_type=Credential.SATELLITE_CRED_TYPE,
username='******',
password='******',
become_password=None,
become_method=None,
become_user=None,
ssh_keyfile=None)
self.cred.save()
self.source = Source(name='source1', port=443, hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.scan_job, self.scan_task = create_scan_job(
self.source, ScanTask.SCAN_TYPE_INSPECT)
self.api = SatelliteFive(self.scan_job, self.scan_task)
connection_results = TaskConnectionResult()
connection_results.save()
self.api.connect_scan_task.connection_result = connection_results
self.api.connect_scan_task.connection_result.save()
sys_result = SystemConnectionResult(
name='sys1_1', status=SystemInspectionResult.SUCCESS)
sys_result.save()
self.api.connect_scan_task.connection_result.systems.add(sys_result)
self.api.connect_scan_task.connection_result.save()
self.api.connect_scan_task.save()
def tearDown(self):
"""Cleanup test case setup."""
pass
@patch('xmlrpc.client.ServerProxy')
def test_host_count(self, mock_serverproxy):
"""Test the method host_count."""
client = mock_serverproxy.return_value
client.auth.login.return_value = 'key'
client.auth.logout.return_value = 'key'
client.system.list_user_systems.return_value = ['sys1', 'sys2', 'sys3']
systems_count = self.api.host_count()
self.assertEqual(systems_count, 3)
@patch('xmlrpc.client.ServerProxy')
def test_host_count_with_err(self, mock_serverproxy):
"""Test the method host_count with error."""
client = mock_serverproxy.return_value
client.auth.login.side_effect = mock_xml_fault
with self.assertRaises(SatelliteException):
self.api.host_count()
@patch('xmlrpc.client.ServerProxy')
def test_hosts(self, mock_serverproxy):
"""Test the method hosts."""
systems = [{
'name': 'sys1',
'id': 1
}, {
'name': 'sys2',
'id': 2
}, {
'name': 'sys3',
'id': 3
}]
client = mock_serverproxy.return_value
client.auth.login.return_value = 'key'
client.auth.logout.return_value = 'key'
client.system.list_user_systems.return_value = systems
systems_count = self.api.host_count()
hosts = self.api.hosts()
self.assertEqual(systems_count, 3)
self.assertEqual(len(hosts), 3)
self.assertEqual(hosts, ['sys1_1', 'sys2_2', 'sys3_3'])
@patch('xmlrpc.client.ServerProxy')
def test_hosts_with_err(self, mock_serverproxy):
"""Test the method hosts with error."""
client = mock_serverproxy.return_value
client.auth.login.side_effect = mock_xml_fault
with self.assertRaises(SatelliteException):
self.api.hosts()
@patch('xmlrpc.client.ServerProxy')
def test_host_details_virt_host(self, mock_serverproxy):
"""Test host_details method with mock data for virt host."""
expected = {
'uuid': 1,
'name': 'sys1',
'hostname': 'sys1_hostname',
'last_checkin_time': '',
'registration_time': 'datetime',
'architecture': 'x86',
'kernel_version': 'kernel',
'cores': 2,
'num_sockets': 2,
'os_release': '7server',
'entitlements': [{
'name': 'ent1'
}],
'ip_addresses': ['1.2.3.4'],
'mac_addresses': ['1:a:2:b:3:c'],
'virtual': 'hypervisor',
'num_virtual_guests': 3,
'is_virtualized': False
}
client = mock_serverproxy.return_value
client.auth.login.return_value = 'key'
client.auth.logout.return_value = 'key'
client.system.get_uuid.return_value = ''
cpu = {'arch': 'x86', 'count': 2, 'socket_count': 2}
client.system.get_cpu.return_value = cpu
system_details = {'hostname': 'sys1_hostname', 'release': '7server'}
client.system.get_details.return_value = system_details
client.system.get_running_kernel.return_value = 'kernel'
client.system.get_entitlements.return_value = ['ent1']
net_devices = [{
'interface': 'eth0',
'ip': '1.2.3.4',
'hardware_address': '1:a:2:b:3:c'
}]
client.system.get_network_devices.return_value = net_devices
client.system.get_registration_date.return_value = 'datetime'
virt = {1: {'id': 1, 'num_virtual_guests': 3}}
logging_options = {
'job_id': self.scan_job.id,
'task_sequence_number': self.scan_task.sequence_number,
'scan_type': self.scan_task.scan_type,
'source_type': self.scan_task.source.source_type,
'source_name': self.scan_task.source.name
}
raw_result = request_host_details(host_id=1,
host_name='sys1',
last_checkin='',
scan_task=self.scan_task,
request_options={},
logging_options=logging_options)
self.api.process_results([raw_result], virt, {1: 2}, [])
inspect_results = \
self.scan_task.inspection_result.systems.all()
sys_1_result = inspect_results.filter(name='sys1_1').first()
self.assertEqual(sys_1_result.name, 'sys1_1')
self.assertEqual(sys_1_result.status, 'success')
result = {}
for fact in sys_1_result.facts.all():
result[fact.name] = json.loads(fact.value)
self.assertEqual(result, expected)
@patch('xmlrpc.client.ServerProxy')
def test_host_details_virt_guest(self, mock_serverproxy):
"""Test host_details method with mock data for virt guest."""
expected = {
'uuid': 1,
'name': 'sys1',
'hostname': 'sys1_hostname',
'last_checkin_time': '',
'registration_time': 'datetime',
'architecture': 'x86',
'kernel_version': 'kernel',
'cores': 2,
'num_sockets': 2,
'os_release': '7server',
'entitlements': [{
'name': 'ent1'
}],
'ip_addresses': ['1.2.3.4'],
'mac_addresses': ['1:a:2:b:3:c'],
'is_virtualized': True,
'virtual_host': 2,
'virtual_host_name': 'sys2'
}
client = mock_serverproxy.return_value
client.auth.login.return_value = 'key'
client.auth.logout.return_value = 'key'
client.system.get_uuid.return_value = ''
cpu = {'arch': 'x86', 'count': 2, 'socket_count': 2}
client.system.get_cpu.return_value = cpu
system_details = {'hostname': 'sys1_hostname', 'release': '7server'}
client.system.get_details.return_value = system_details
client.system.get_running_kernel.return_value = 'kernel'
client.system.get_entitlements.return_value = ['ent1']
net_devices = [{
'interface': 'eth0',
'ip': '1.2.3.4',
'hardware_address': '1:a:2:b:3:c'
}]
client.system.get_network_devices.return_value = net_devices
client.system.get_registration_date.return_value = 'datetime'
virt = {2: {'uuid': 2, 'name': 'sys2', 'num_virtual_guests': 3}}
raw_result = request_host_details(host_id=1,
host_name='sys1',
last_checkin='',
scan_task=self.scan_task,
request_options={},
logging_options=None)
self.api.process_results([raw_result], virt, {1: 2}, [])
inspect_results = \
self.scan_task.inspection_result.systems.all()
sys_1_result = inspect_results.filter(name='sys1_1').first()
self.assertEqual(sys_1_result.name, 'sys1_1')
self.assertEqual(sys_1_result.status, 'success')
result = {}
for fact in sys_1_result.facts.all():
result[fact.name] = json.loads(fact.value)
self.assertEqual(result, expected)
def test_prepare_host_s5(self):
"""Test the prepare host method for satellite 5."""
expected = [(1, 'sys', '', self.scan_task, {
'host': {
'id': 1,
'name': 'sys',
'last_checkin': ''
},
'port': '443',
'user': self.cred.username,
'password': self.cred.password,
'ssl_cert_verify': True
}, {
'job_id': self.scan_job.id,
'task_sequence_number': self.scan_task.sequence_number,
'scan_type': self.scan_task.scan_type,
'source_type': self.scan_task.source.source_type,
'source_name': self.scan_task.source.name
})]
host = {'id': 1, 'name': 'sys', 'last_checkin': ''}
chunk = [host]
port = '443'
user = self.cred.username
password = self.cred.password
connect_data_return_value = host, port, user, password
with patch('scanner.satellite.utils.get_connect_data',
return_value=connect_data_return_value) as mock_connect:
host_params = self.api.prepare_host(chunk)
self.assertEqual(expected, host_params)
mock_connect.assert_called_once_with(ANY)
@patch('xmlrpc.client.ServerProxy')
def test_host_details_with_err(self, mock_serverproxy):
"""Test the host details with an error."""
client = mock_serverproxy.return_value
client.auth.login.side_effect = mock_xml_fault
virt = {2: {'uuid': 2, 'name': 'sys2', 'num_virtual_guests': 3}}
raw_result = request_host_details(host_id=2,
host_name='sys2',
last_checkin='',
scan_task=self.scan_task,
request_options={},
logging_options=None)
self.api.process_results([raw_result], virt, {1: 2}, [])
inspect_results = \
self.scan_task.inspection_result.systems.all()
sys_1_result = inspect_results.filter(name='sys2_2').first()
self.assertEqual(sys_1_result.name, 'sys2_2')
self.assertEqual(sys_1_result.status, 'failed')
result = {}
for fact in sys_1_result.facts.all():
result[fact.name] = json.loads(fact.value)
self.assertEqual(result, {})
@patch('xmlrpc.client.ServerProxy')
def test_virtual_guests_with_err(self, mock_serverproxy):
"""Test the virtual_guests method with an error."""
client = mock_serverproxy.return_value
client.auth.login.side_effect = mock_xml_fault
with self.assertRaises(SatelliteException):
self.api.virtual_guests(1)
@patch('xmlrpc.client.ServerProxy')
def test_virtual_guests(self, mock_serverproxy):
"""Test the virtual_guests method with an error."""
client = mock_serverproxy.return_value
client.auth.login.return_value = 'key'
client.auth.logout.return_value = 'key'
guests = [{'id': 2}]
client.system.list_virtual_guests.return_value = guests
virt_guests = self.api.virtual_guests(1)
self.assertEqual(virt_guests, ({2: 1}, 1))
@patch('xmlrpc.client.ServerProxy')
def test_virtual_hosts_with_err(self, mock_serverproxy):
"""Test the virtual_hosts method with an error."""
client = mock_serverproxy.return_value
client.auth.login.side_effect = mock_xml_fault
with self.assertRaises(SatelliteException):
self.api.virtual_hosts()
@patch('xmlrpc.client.ServerProxy')
def test_virtual_hosts(self, mock_serverproxy):
"""Test the virtual_hosts method."""
client = mock_serverproxy.return_value
client.auth.login.return_value = 'key'
client.auth.logout.return_value = 'key'
guests = [{'id': 2}]
client.system.list_virtual_guests.return_value = guests
hosts = [{'id': 1, 'name': 'host1'}]
client.system.list_virtual_hosts.return_value = hosts
client.system.get_uuid.return_value = ''
virtual_hosts, virtual_guests = self.api.virtual_hosts()
virt_host = {
1: {
'id': 1,
'name': 'host1',
'uuid': 1,
'num_virtual_guests': 1
}
}
virt_guest = {2: 1}
self.assertEqual(virtual_hosts, virt_host)
self.assertEqual(virtual_guests, virt_guest)
@patch('xmlrpc.client.ServerProxy')
def test_physical_hosts_with_err(self, mock_serverproxy):
"""Test the phyiscal_hosts method with an error."""
client = mock_serverproxy.return_value
client.auth.login.side_effect = mock_xml_fault
with self.assertRaises(SatelliteException):
self.api.physical_hosts()
@patch('xmlrpc.client.ServerProxy')
def test_physical_hosts(self, mock_serverproxy):
"""Test the physical_hosts method."""
client = mock_serverproxy.return_value
client.auth.login.return_value = 'key'
client.auth.logout.return_value = 'key'
hosts = [{'id': 1, 'name': 'host1'}]
client.system.list_physical_systems.return_value = hosts
phyiscal_hosts = self.api.physical_hosts()
self.assertEqual(phyiscal_hosts, [1])
@patch('xmlrpc.client.ServerProxy')
def test_hosts_facts_with_err(self, mock_serverproxy):
"""Test the hosts_facts method with an error."""
client = mock_serverproxy.return_value
client.auth.login.side_effect = mock_xml_fault
with self.assertRaises(SatelliteException):
self.api.hosts_facts(Value('i', ScanJob.JOB_RUN))
@patch('multiprocessing.pool.Pool.starmap',
return_value=[{
'host_name':
'sys10',
'last_checkin':
'',
'host_id':
1,
'cpu': {},
'uuid':
1,
'system_details': {},
'kernel':
'',
'subs': [],
'network_devices': [],
'registration_date':
'',
'system_inspection_result':
SystemInspectionResult.SUCCESS
}])
@patch('xmlrpc.client.ServerProxy')
def test_hosts_facts(self, mock_serverproxy, mock_pool):
"""Test the hosts_facts method."""
# pylint: disable=unused-argument
systems = [{'id': 1, 'name': 'sys1'}]
client = mock_serverproxy.return_value
client.auth.login.return_value = 'key'
client.auth.logout.return_value = 'key'
client.system.list_user_systems.return_value = systems
hosts_return_value = ({}, {})
with patch.object(SatelliteFive,
'virtual_hosts',
return_value=hosts_return_value) as mock_vhosts:
with patch.object(SatelliteFive, 'physical_hosts',
return_value=[]) as mock_physical:
self.api.hosts_facts(Value('i', ScanJob.JOB_RUN))
inspect_result = self.scan_task.inspection_result
self.assertEqual(len(inspect_result.systems.all()), 1)
mock_vhosts.assert_called_once_with()
mock_physical.assert_called_once_with()
class SatelliteSixV1Test(TestCase):
"""Tests Satellite 6 v1 functions."""
def setUp(self):
"""Create test case setup."""
self.cred = Credential(name='cred1',
cred_type=Credential.SATELLITE_CRED_TYPE,
username='******',
password='******',
become_password=None,
become_method=None,
become_user=None,
ssh_keyfile=None)
self.cred.save()
self.source = Source(name='source1', port=443, hosts='["1.2.3.4"]')
self.source.save()
self.source.credentials.add(self.cred)
self.scan_job, self.scan_task = create_scan_job(
self.source, ScanTask.SCAN_TYPE_INSPECT)
self.api = SatelliteSixV1(self.scan_job, self.scan_task)
job_conn_result = JobConnectionResult()
job_conn_result.save()
connection_results = TaskConnectionResult(
job_connection_result=job_conn_result)
connection_results.save()
self.api.connect_scan_task.connection_result = connection_results
self.api.connect_scan_task.connection_result.save()
conn_result = self.api.connect_scan_task.connection_result
sys_result = SystemConnectionResult(
name='sys1_1',
status=SystemInspectionResult.SUCCESS,
task_connection_result=conn_result)
sys_result.save()
self.api.connect_scan_task.save()
def tearDown(self):
"""Cleanup test case setup."""
pass
def test_get_orgs(self):
"""Test the method to get orgs."""
orgs_url = 'https://{sat_host}:{port}/katello/api/v2/organizations'
with requests_mock.Mocker() as mocker:
url = construct_url(orgs_url, '1.2.3.4')
jsonresult = {
'results': [{
'id': 1
}, {
'id': 7
}, {
'id': 8
}],
'per_page': 100
}
mocker.get(url, status_code=200, json=jsonresult)
orgs = self.api.get_orgs()
orgs2 = self.api.get_orgs()
self.assertEqual(orgs, [1, 7, 8])
self.assertEqual(orgs, orgs2)
def test_get_orgs_with_err(self):
"""Test the method to get orgs with err."""
orgs_url = 'https://{sat_host}:{port}/katello/api/v2/organizations'
with requests_mock.Mocker() as mocker:
url = construct_url(orgs_url, '1.2.3.4')
jsonresult = {
'results': [{
'id': 1
}, {
'id': 7
}, {
'id': 8
}],
'per_page': 100
}
mocker.get(url, status_code=500, json=jsonresult)
with self.assertRaises(SatelliteException):
self.api.get_orgs()
@patch('scanner.satellite.six.SatelliteSixV1.get_orgs')
def test_host_count(self, mock_get_orgs):
"""Test the method host_count."""
mock_get_orgs.return_value = [1]
hosts_url = 'https://{sat_host}:{port}/katello/api' \
'/v2/organizations/{org_id}/systems'
with requests_mock.Mocker() as mocker:
url = construct_url(url=hosts_url, sat_host='1.2.3.4', org_id=1)
jsonresult = {
'results': [{
'name': 'sys1'
}, {
'name': 'sys2'
}, {
'name': 'sys3'
}],
'per_page': 100,
'total': 3
}
mocker.get(url, status_code=200, json=jsonresult)
systems_count = self.api.host_count()
self.assertEqual(systems_count, 3)
@patch('scanner.satellite.six.SatelliteSixV1.get_orgs')
def test_host_count_with_err(self, mock_get_orgs):
"""Test the method host_count with err."""
mock_get_orgs.return_value = [1]
hosts_url = 'https://{sat_host}:{port}/katello/api' \
'/v2/organizations/{org_id}/systems'
with requests_mock.Mocker() as mocker:
url = construct_url(url=hosts_url, sat_host='1.2.3.4', org_id=1)
jsonresult = {
'results': [{
'name': 'sys1'
}, {
'name': 'sys2'
}, {
'name': 'sys3'
}],
'per_page': 100,
'total': 3
}
mocker.get(url, status_code=500, json=jsonresult)
with self.assertRaises(SatelliteException):
self.api.host_count()
@patch('scanner.satellite.six.SatelliteSixV1.get_orgs')
def test_hosts(self, mock_get_orgs):
"""Test the method hosts."""
mock_get_orgs.return_value = [1]
hosts_url = 'https://{sat_host}:{port}/katello/api' \
'/v2/organizations/{org_id}/systems'
with requests_mock.Mocker() as mocker:
url = construct_url(url=hosts_url, sat_host='1.2.3.4', org_id=1)
jsonresult = {
'results': [{
'name': 'sys1',
'id': 1
}, {
'name': 'sys2',
'id': 2
}, {
'name': 'sys3',
'id': 3
}],
'per_page':
100,
'total':
3
}
mocker.get(url, status_code=200, json=jsonresult)
systems_count = self.api.host_count()
hosts = self.api.hosts()
self.assertEqual(systems_count, 3)
self.assertEqual(len(hosts), 3)
self.assertEqual(hosts, ['sys1_1', 'sys2_2', 'sys3_3'])
@patch('scanner.satellite.six.SatelliteSixV1.get_orgs')
def test_hosts_with_err(self, mock_get_orgs):
"""Test the method hosts."""
mock_get_orgs.return_value = [1]
hosts_url = 'https://{sat_host}:{port}/katello/api' \
'/v2/organizations/{org_id}/systems'
with requests_mock.Mocker() as mocker:
url = construct_url(url=hosts_url, sat_host='1.2.3.4', org_id=1)
jsonresult = {
'results': [{
'name': 'sys1'
}, {
'name': 'sys2'
}, {
'name': 'sys3'
}],
'per_page': 100,
'total': 3
}
mocker.get(url, status_code=500, json=jsonresult)
with self.assertRaises(SatelliteException):
self.api.hosts()
def test_host_fields(self):
"""Test the method host_fields."""
host_field_url = 'https://{sat_host}:{port}/api/v2/hosts/{host_id}'
with requests_mock.Mocker() as mocker:
url = construct_url(url=host_field_url,
sat_host='1.2.3.4',
host_id=1)
jsonresult = {
'architecture_id': 1,
'architecture_name': 'x86_64',
'operatingsystem_name': 'RedHat 7.4',
'uuid': None,
'created_at': '2017-12-04 13:19:57 UTC',
'updated_at': '2017-12-04 13:21:47 UTC',
'organization_name': 'ACME',
'location_name': 'Raleigh',
'name': 'mac52540071bafe.prov.lan',
'virtual_host': {
'uuid': '100',
'name': 'vhost1'
},
'virtual_guests': [{
'name': 'foo'
}],
'content_facet_attributes': {
'id': 11,
'katello_agent_installed': False
},
'subscription_facet_attributes': {
'uuid': '00c7a108-48ec-4a97-835c-aa3369777f64',
'last_checkin': '2018-01-04 17:36:07 UTC',
'registered_at': '2017-12-04 13:33:52 UTC',
'registered_by': 'sat-r220-07.lab.eng.rdu2.redhat.com',
'virtual_host': {
'uuid': '100',
'name': 'vhost1'
},
'virtual_guests': [{
'name': 'foo'
}],
},
'facts': {
'memorysize_mb': '992.45',
'memorysize': '992.45 MB',
'hostname': 'fdi',
'type': 'Other',
'architecture': 'x86_64',
'is_virtual': 'true',
'virtual': 'kvm',
'net.interface.ipv4_address': '192.168.99.123',
'net.interface.mac_address': 'fe80::5054:ff:fe24:946e',
},
}
mocker.get(url, status_code=200, json=jsonresult)
host_info = host_fields(1, jsonresult)
expected = {
'uuid': '00c7a108-48ec-4a97-835c-aa3369777f64',
'hostname': 'mac52540071bafe.prov.lan',
'registered_by': 'sat-r220-07.lab.eng.rdu2.redhat.com',
'registration_time': '2017-12-04 13:33:52 UTC',
'last_checkin_time': '2018-01-04 17:36:07 UTC',
'katello_agent_installed': False,
'os_release': 'RedHat 7.4',
'organization': 'ACME',
'virtual_host_uuid': '100',
'virtual_host_name': 'vhost1',
'virt_type': None,
'kernel_version': None,
'architecture': None,
'is_virtualized': None,
'cores': None,
'num_sockets': None,
'num_virtual_guests': 1,
'virtual': 'hypervisor',
'location': 'Raleigh',
'ip_addresses': ['192.168.99.123'],
'mac_addresses': ['fe80::5054:ff:fe24:946e'],
'os_name': 'RedHat',
'os_version': '7.4'
}
self.assertEqual(host_info, expected)
def test_prepare_host_s61(self):
"""Test the prepare host method for satellite 6.1."""
url1 = \
'https://{sat_host}:{port}/katello/api' \
'/v2/organizations/{org_id}/systems/{host_id}'
url2 = \
'https://{sat_host}:{port}/katello/api' \
'/v2/organizations/{org_id}/systems/{host_id}/subscriptions'
expected = [(self.scan_task, {
'job_id': self.scan_job.id,
'task_sequence_number': self.scan_task.sequence_number,
'scan_type': self.scan_task.scan_type,
'source_type': self.scan_task.source.source_type,
'source_name': self.scan_task.source.name
}, 1, 'sys', url1, url2, {
'host': {
'id': 1,
'name': 'sys'
},
'port': '443',
'user': self.cred.username,
'password': self.cred.password,
'ssl_cert_verify': True
})]
host = {'id': 1, 'name': 'sys'}
chunk = [host]
port = '443'
user = self.cred.username
password = self.cred.password
connect_data_return_value = host, port, user, password
with patch('scanner.satellite.utils.get_connect_data',
return_value=connect_data_return_value) as mock_connect:
host_params = SatelliteSixV1.prepare_host(self.api, chunk)
self.assertEqual(expected, host_params)
mock_connect.assert_called_once_with(ANY)
def test_request_host_details_err(self):
"""Test request_host_details for error mark a failed system."""
host_field_url = 'https://{sat_host}:{port}/api/v2/hosts/{host_id}'
with requests_mock.Mocker() as mocker:
url = construct_url(url=host_field_url,
sat_host='1.2.3.4',
host_id=1)
mocker.get(url, status_code=500)
result = request_host_details(
self.scan_task, {
'job_id': self.scan_job.id,
'task_sequence_number': self.scan_task.id,
'scan_type': self.scan_task.scan_type,
'source_type': self.scan_task.source.source_type,
'source_name': self.scan_task.source.name
}, 1, 'sys', url, url, {})
expected = {
'unique_name': 'sys_1',
'system_inspection_result': 'failed',
'host_fields_response': {},
'host_subscriptions_response': {}
}
self.assertEqual(result, expected)
inspect_result = self.scan_task.inspection_result
self.assertEqual(len(inspect_result.systems.all()), 0)
def test_post_processing(self):
"""Test process_results method with mock data."""
fields_return_value = {
'uuid': '00c7a108-48ec-4a97-835c-aa3369777f64',
'hostname': 'mac52540071bafe.prov.lan',
'registered_by': 'sat-r220-07.lab.eng.rdu2.redhat.com',
'registration_time': '2017-12-04 13:33:52 UTC',
'last_checkin_time': '2018-01-04 17:36:07 UTC',
'katello_agent_installed': False,
'os_name': 'RedHat 7.4',
'organization': 'ACME',
'virtual_host_uuid': '100',
'virtual_host_name': 'vhost1',
'virt_type': None,
'kernel_version': None,
'architecture': None,
'is_virtualized': None,
'cores': None,
'num_sockets': None,
'num_virtual_guests': 1,
'virtual': 'hypervisor',
'location': 'Raleigh',
'ip_addresses': ['192.168.99.123'],
'ipv6_addresses': ['fe80::5054:ff:fe24:946e']
}
subs_return_value = {
'entitlements': [{
'derived_entitlement': False,
'name': 'Satellite Tools 6.3',
'amount': 1,
'account_number': None,
'contract_number': None,
'start_date': '2017-12-01 14:50:59 UTC',
'end_date': '2047-11-24 14:50:59 UTC'
}, {
'derived_entitlement': True,
'name': 'Employee SKU',
'amount': 1,
'account_number': 1212729,
'contract_number': 10913844,
'start_date': '2016-03-24 04:00:00 UTC',
'end_date': '2022-01-01 04:59:59 UTC'
}]
}
expected = {
'uuid':
'00c7a108-48ec-4a97-835c-aa3369777f64',
'hostname':
'mac52540071bafe.prov.lan',
'registered_by':
'sat-r220-07.lab.eng.rdu2.redhat.com',
'registration_time':
'2017-12-04 13:33:52 UTC',
'last_checkin_time':
'2018-01-04 17:36:07 UTC',
'katello_agent_installed':
False,
'os_name':
'RedHat 7.4',
'organization':
'ACME',
'virtual_host_uuid':
'100',
'virtual_host_name':
'vhost1',
'num_virtual_guests':
1,
'virtual':
'hypervisor',
'location':
'Raleigh',
'ip_addresses': ['192.168.99.123'],
'ipv6_addresses': ['fe80::5054:ff:fe24:946e'],
'entitlements': [{
'derived_entitlement': False,
'name': 'Satellite Tools 6.3',
'amount': 1,
'account_number': None,
'contract_number': None,
'start_date': '2017-12-01 14:50:59 UTC',
'end_date': '2047-11-24 14:50:59 UTC'
}, {
'derived_entitlement': True,
'name': 'Employee SKU',
'amount': 1,
'account_number': 1212729,
'contract_number': 10913844,
'start_date': '2016-03-24 04:00:00 UTC',
'end_date': '2022-01-01 04:59:59 UTC'
}]
}
self.scan_task.save()
self.scan_task.update_stats('TEST_SAT.', sys_scanned=0)
with patch('scanner.satellite.six.host_fields',
return_value=fields_return_value) as mock_fields:
with patch('scanner.satellite.six.host_subscriptions',
return_value=subs_return_value) as mock_subs:
result = {
'unique_name': 'sys_1',
'system_inspection_result': SystemInspectionResult.SUCCESS,
'host_fields_response': fields_return_value,
'host_subscriptions_response': subs_return_value
}
process_results(self.api, [result], 1)
inspect_results = \
self.scan_task.inspection_result.systems.all()
sys_1_result = inspect_results.filter(name='sys_1').first()
self.assertEqual(sys_1_result.name, 'sys_1')
self.assertEqual(sys_1_result.status, 'success')
result = {}
for fact in sys_1_result.facts.all():
result[fact.name] = json.loads(fact.value)
self.assertEqual(result, expected)
mock_fields.assert_called_once_with(ANY, ANY)
mock_subs.assert_called_once_with(ANY)
@patch('scanner.satellite.six.SatelliteSixV1.get_orgs')
def test_hosts_facts_with_err(self, mock_get_orgs):
"""Test the hosts_facts method."""
mock_get_orgs.return_value = [1]
hosts_url = 'https://{sat_host}:{port}/katello/api' \
'/v2/organizations/{org_id}/systems'
with requests_mock.Mocker() as mocker:
url = construct_url(url=hosts_url, sat_host='1.2.3.4', org_id=1)
mocker.get(url, status_code=500)
with self.assertRaises(SatelliteException):
self.api.hosts_facts(Value('i', ScanJob.JOB_RUN))
@patch('multiprocessing.pool.Pool.starmap',
return_value=[{
'unique_name': 'sys_1',
'system_inspection_result': 'failed',
'host_fields_response': {},
'host_subscriptions_response': {}
}])
def test_hosts_facts(self, mock_pool):
"""Test the method hosts."""
hosts_url = 'https://{sat_host}:{port}/katello/api' \
'/v2/organizations/{org_id}/systems'
with patch.object(SatelliteSixV1, 'get_orgs', return_value=[1]):
with patch('scanner.satellite.six.request_host_details',
return_value={}):
with requests_mock.Mocker() as mocker:
url = construct_url(url=hosts_url,
sat_host='1.2.3.4',
org_id=1)
jsonresult = {
'results': [{
'uuid': '1',
'name': 'sys1'
}, {
'uuid': '2',
'name': 'sys2'
}, {
'uuid': '3',
'name': 'sys3'
}],
'per_page':
100,
'total':
3
}
mocker.get(url, status_code=200, json=jsonresult)
self.api.hosts_facts(Value('i', ScanJob.JOB_RUN))
inspect_result = self.scan_task.inspection_result
self.assertEqual(len(inspect_result.systems.all()), 1)
