def test_reconfigure(self): autospec_method(self.mcp._load_config) self.mcp.state_watcher = mock.MagicMock() self.mcp.reconfigure() self.mcp._load_config.assert_called_with(reconfigure=True)
def test_run_direct(self): test_class2_mock = mock.MagicMock() lc_test.run_direct(test_class2_mock, 'class name') test_class2_mock().run.assert_called_once_with()
def test_repository_delete(self, mock_requests_get, mock_requests_delete, mock_get_access_credentials, mock_get_registry_by_name): cmd = mock.MagicMock() cmd.cli_ctx = DummyCli() get_response = mock.MagicMock() get_response.headers = { 'Docker-Content-Digest': 'sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7' } get_response.status_code = 200 mock_requests_get.return_value = get_response delete_response = mock.MagicMock() delete_response.headers = {} delete_response.status_code = 200 mock_requests_delete.return_value = delete_response mock_get_registry_by_name.return_value = Registry(location='westus', sku=Sku(name='Standard')), 'testrg' mock_get_access_credentials.return_value = 'testregistry.azurecr.io', 'username', 'password' # Delete repository acr_repository_delete(cmd, registry_name='testregistry', repository='testrepository', yes=True) mock_requests_delete.assert_called_with( method='delete', url='https://testregistry.azurecr.io/v2/_acr/testrepository/repository', headers=_get_authorization_header('username', 'password'), params=None, json=None, verify=mock.ANY) # Delete image by tag acr_repository_delete(cmd, registry_name='testregistry', image='testrepository:testtag', yes=True) expected_get_headers = _get_authorization_header('username', 'password') expected_get_headers.update(MANIFEST_V2_HEADER) mock_requests_get.assert_called_with( url='https://testregistry.azurecr.io/v2/testrepository/manifests/testtag', headers=expected_get_headers, verify=mock.ANY) mock_requests_delete.assert_called_with( method='delete', url='https://testregistry.azurecr.io/v2/testrepository/manifests/sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7', headers=_get_authorization_header('username', 'password'), params=None, json=None, verify=mock.ANY) # Delete image by manifest digest acr_repository_delete(cmd, registry_name='testregistry', image='testrepository@sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7', yes=True) mock_requests_delete.assert_called_with( method='delete', url='https://testregistry.azurecr.io/v2/testrepository/manifests/sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7', headers=_get_authorization_header('username', 'password'), params=None, json=None, verify=mock.ANY) # Untag image acr_repository_untag(cmd, registry_name='testregistry', image='testrepository:testtag') mock_requests_delete.assert_called_with( method='delete', url='https://testregistry.azurecr.io/v2/_acr/testrepository/tags/testtag', headers=_get_authorization_header('username', 'password'), params=None, json=None, verify=mock.ANY) # Delete tag (deprecating) acr_repository_delete(cmd, 'testregistry', 'testrepository', tag='testtag', yes=True) mock_requests_delete.assert_called_with( method='delete', url='https://testregistry.azurecr.io/v2/_acr/testrepository/tags/testtag', headers=_get_authorization_header('username', 'password'), params=None, json=None, verify=mock.ANY) # Delete manifest with tag (deprecating) acr_repository_delete(cmd, 'testregistry', 'testrepository', tag='testtag', manifest='', yes=True) expected_get_headers = _get_authorization_header('username', 'password') expected_get_headers.update(MANIFEST_V2_HEADER) mock_requests_get.assert_called_with( url='https://testregistry.azurecr.io/v2/testrepository/manifests/testtag', headers=expected_get_headers, verify=mock.ANY) mock_requests_delete.assert_called_with( method='delete', url='https://testregistry.azurecr.io/v2/testrepository/manifests/sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7', headers=_get_authorization_header('username', 'password'), params=None, json=None, verify=mock.ANY) # Delete manifest with digest (deprecating) acr_repository_delete(cmd, 'testregistry', 'testrepository', manifest='sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7', yes=True) mock_requests_delete.assert_called_with( method='delete', url='https://testregistry.azurecr.io/v2/testrepository/manifests/sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7', headers=_get_authorization_header('username', 'password'), params=None, json=None, verify=mock.ANY)
def logger(monkeypatch): mock_logger = mock.MagicMock() mock_get_logger = mock.MagicMock() mock_get_logger.return_value = mock_logger monkeypatch.setattr('logging.getLogger', mock_get_logger) return mock_logger
class ProcessAlertsTest(testing_common.TestCase): def setUp(self): super(ProcessAlertsTest, self).setUp() self.SetCurrentUser('*****@*****.**', is_admin=True) def _AddDataForTests(self): testing_common.AddTests( ['ChromiumGPU'], ['linux-release'], { 'scrolling_benchmark': { 'ref': {}, }, }) ref = utils.TestKey( 'ChromiumGPU/linux-release/scrolling_benchmark/ref').get() for i in range(9000, 10070, 5): # Internal-only data should be found. test_container_key = utils.GetTestContainerKey(ref.key) graph_data.Row( id=i + 1, value=float(i * 3), parent=test_container_key, internal_only=True).put() @mock.patch.object( find_anomalies.find_change_points, 'FindChangePoints', mock.MagicMock(return_value=[ _MakeSampleChangePoint(10011, 50, 100), _MakeSampleChangePoint(10041, 200, 100), _MakeSampleChangePoint(10061, 0, 100), ])) @mock.patch.object(find_anomalies.email_sheriff, 'EmailSheriff') def testProcessTest(self, mock_email_sheriff): self._AddDataForTests() test_path = 'ChromiumGPU/linux-release/scrolling_benchmark/ref' test = utils.TestKey(test_path).get() sheriff.Sheriff( email='*****@*****.**', id='sheriff', patterns=[test_path]).put() test.put() find_anomalies.ProcessTest(test.key) expected_calls = [ mock.call(ModelMatcher('sheriff'), ModelMatcher('ref'), EndRevisionMatcher(10011)), mock.call(ModelMatcher('sheriff'), ModelMatcher('ref'), EndRevisionMatcher(10041)), mock.call(ModelMatcher('sheriff'), ModelMatcher('ref'), EndRevisionMatcher(10061))] self.assertEqual(expected_calls, mock_email_sheriff.call_args_list) anomalies = anomaly.Anomaly.query().fetch() self.assertEqual(len(anomalies), 3) def AnomalyExists( anomalies, test, percent_changed, direction, start_revision, end_revision, sheriff_name, internal_only): for a in anomalies: if (a.test == test and a.percent_changed == percent_changed and a.direction == direction and a.start_revision == start_revision and a.end_revision == end_revision and a.sheriff.string_id() == sheriff_name and a.internal_only == internal_only): return True return False self.assertTrue( AnomalyExists( anomalies, test.key, percent_changed=100, direction=anomaly.UP, start_revision=10007, end_revision=10011, sheriff_name='sheriff', internal_only=False)) self.assertTrue( AnomalyExists( anomalies, test.key, percent_changed=-50, direction=anomaly.DOWN, start_revision=10037, end_revision=10041, sheriff_name='sheriff', internal_only=False)) self.assertTrue( AnomalyExists( anomalies, test.key, percent_changed=sys.float_info.max, direction=anomaly.UP, start_revision=10057, end_revision=10061, sheriff_name='sheriff', internal_only=False)) # This is here just to verify that AnomalyExists returns False sometimes. self.assertFalse( AnomalyExists( anomalies, test.key, percent_changed=100, direction=anomaly.DOWN, start_revision=10037, end_revision=10041, sheriff_name='sheriff', internal_only=False)) @mock.patch.object( find_anomalies.find_change_points, 'FindChangePoints', mock.MagicMock(return_value=[ _MakeSampleChangePoint(10011, 100, 50) ])) def testProcessTest_ImprovementMarkedAsImprovement(self): self._AddDataForTests() test = utils.TestKey( 'ChromiumGPU/linux-release/scrolling_benchmark/ref').get() sheriff.Sheriff( email='*****@*****.**', id='sheriff', patterns=[test.test_path]).put() test.improvement_direction = anomaly.DOWN test.put() find_anomalies.ProcessTest(test.key) anomalies = anomaly.Anomaly.query().fetch() self.assertEqual(len(anomalies), 1) self.assertTrue(anomalies[0].is_improvement) @mock.patch('logging.error') def testProcessTest_NoSheriff_ErrorLogged(self, mock_logging_error): self._AddDataForTests() ref = utils.TestKey( 'ChromiumGPU/linux-release/scrolling_benchmark/ref').get() find_anomalies.ProcessTest(ref.key) mock_logging_error.assert_called_with('No sheriff for %s', ref.key) @mock.patch.object( find_anomalies.find_change_points, 'FindChangePoints', mock.MagicMock(return_value=[ _MakeSampleChangePoint(10026, 55.2, 57.8), _MakeSampleChangePoint(10041, 45.2, 37.8), ])) @mock.patch.object(find_anomalies.email_sheriff, 'EmailSheriff') def testProcessTest_FiltersOutImprovements(self, mock_email_sheriff): self._AddDataForTests() test = utils.TestKey( 'ChromiumGPU/linux-release/scrolling_benchmark/ref').get() sheriff.Sheriff( email='*****@*****.**', id='sheriff', patterns=[test.test_path]).put() test.improvement_direction = anomaly.UP test.put() find_anomalies.ProcessTest(test.key) mock_email_sheriff.assert_called_once_with( ModelMatcher('sheriff'), ModelMatcher('ref'), EndRevisionMatcher(10041)) @mock.patch.object( find_anomalies.find_change_points, 'FindChangePoints', mock.MagicMock(return_value=[ _MakeSampleChangePoint(10011, 50, 100), ])) @mock.patch.object(find_anomalies.email_sheriff, 'EmailSheriff') def testProcessTest_InternalOnlyTest(self, mock_email_sheriff): self._AddDataForTests() test = utils.TestKey( 'ChromiumGPU/linux-release/scrolling_benchmark/ref').get() test.internal_only = True sheriff.Sheriff( email='*****@*****.**', id='sheriff', patterns=[test.test_path]).put() test.put() find_anomalies.ProcessTest(test.key) expected_calls = [ mock.call(ModelMatcher('sheriff'), ModelMatcher('ref'), EndRevisionMatcher(10011))] self.assertEqual(expected_calls, mock_email_sheriff.call_args_list) anomalies = anomaly.Anomaly.query().fetch() self.assertEqual(len(anomalies), 1) self.assertEqual(test.key, anomalies[0].test) self.assertEqual(100, anomalies[0].percent_changed) self.assertEqual(anomaly.UP, anomalies[0].direction) self.assertEqual(10007, anomalies[0].start_revision) self.assertEqual(10011, anomalies[0].end_revision) self.assertTrue(anomalies[0].internal_only) def testProcessTest_AnomaliesMatchRefSeries_NoAlertCreated(self): # Tests that a Anomaly entity is not created if both the test and its # corresponding ref build series have the same data. testing_common.AddTests( ['ChromiumGPU'], ['linux-release'], { 'scrolling_benchmark': {'ref': {}}, }) ref = utils.TestKey( 'ChromiumGPU/linux-release/scrolling_benchmark/ref').get() non_ref = utils.TestKey( 'ChromiumGPU/linux-release/scrolling_benchmark').get() test_container_key = utils.GetTestContainerKey(ref.key) test_container_key_non_ref = utils.GetTestContainerKey(non_ref.key) for row in _TEST_ROW_DATA: graph_data.Row(id=row[0], value=row[1], parent=test_container_key).put() graph_data.Row(id=row[0], value=row[1], parent=test_container_key_non_ref).put() sheriff.Sheriff( email='*****@*****.**', id='sheriff', patterns=[non_ref.test_path]).put() ref.put() non_ref.put() find_anomalies.ProcessTest(non_ref.key) new_anomalies = anomaly.Anomaly.query().fetch() self.assertEqual(0, len(new_anomalies)) def testProcessTest_AnomalyDoesNotMatchRefSeries_AlertCreated(self): # Tests that an Anomaly entity is created when non-ref series goes up, but # the ref series stays flat. testing_common.AddTests( ['ChromiumGPU'], ['linux-release'], { 'scrolling_benchmark': {'ref': {}}, }) ref = utils.TestKey( 'ChromiumGPU/linux-release/scrolling_benchmark/ref').get() non_ref = utils.TestKey( 'ChromiumGPU/linux-release/scrolling_benchmark').get() test_container_key = utils.GetTestContainerKey(ref.key) test_container_key_non_ref = utils.GetTestContainerKey(non_ref.key) for row in _TEST_ROW_DATA: graph_data.Row(id=row[0], value=2125.375, parent=test_container_key).put() graph_data.Row(id=row[0], value=row[1], parent=test_container_key_non_ref).put() sheriff.Sheriff( email='*****@*****.**', id='sheriff', patterns=[ref.test_path]).put() sheriff.Sheriff( email='*****@*****.**', id='sheriff', patterns=[non_ref.test_path]).put() ref.put() non_ref.put() find_anomalies.ProcessTest(non_ref.key) new_anomalies = anomaly.Anomaly.query().fetch() self.assertEqual(len(new_anomalies), 1) def testProcessTest_CreatesAnAnomaly(self): testing_common.AddTests( ['ChromiumGPU'], ['linux-release'], { 'scrolling_benchmark': {'ref': {}}, }) ref = utils.TestKey( 'ChromiumGPU/linux-release/scrolling_benchmark/ref').get() test_container_key = utils.GetTestContainerKey(ref.key) for row in _TEST_ROW_DATA: graph_data.Row(id=row[0], value=row[1], parent=test_container_key).put() sheriff.Sheriff( email='*****@*****.**', id='sheriff', patterns=[ref.test_path]).put() ref.put() find_anomalies.ProcessTest(ref.key) new_anomalies = anomaly.Anomaly.query().fetch() self.assertEqual(1, len(new_anomalies)) self.assertEqual(anomaly.UP, new_anomalies[0].direction) self.assertEqual(241536, new_anomalies[0].start_revision) self.assertEqual(241537, new_anomalies[0].end_revision) @mock.patch('logging.error') def testProcessTest_LastAlertedRevisionTooHigh_PropertyReset( self, mock_logging_error): # If the last_alerted_revision property of the Test is too high, # then the property should be reset and an error should be logged. self._AddDataForTests() test = utils.TestKey( 'ChromiumGPU/linux-release/scrolling_benchmark/ref').get() test.last_alerted_revision = 1234567890 test.put() find_anomalies.ProcessTest(test.key) self.assertIsNone(test.key.get().last_alerted_revision) calls = [ mock.call( 'last_alerted_revision %d is higher than highest rev %d for test ' '%s; setting last_alerted_revision to None.', 1234567890, 10066, 'ChromiumGPU/linux-release/scrolling_benchmark/ref'), mock.call( 'No rows fetched for %s', 'ChromiumGPU/linux-release/scrolling_benchmark/ref') ] mock_logging_error.assert_has_calls(calls, any_order=True)
def test_runDarwin(self, getTempDirMock, permsUser, timeMock, popenMock): # given currentTime = 1568070634.3 jobTempPath = '/job/temp/path/' logDir = '/path/to/log/dir/' tempDir = '/some/random/temp/dir' frameId = 'arbitrary-frame-id' jobName = 'arbitrary-job-name' frameName = 'arbitrary-frame-name' frameUid = 928 frameUsername = '******' returnCode = 0 renderHost = rqd.compiled_proto.report_pb2.RenderHost(name='arbitrary-host-name') logFile = os.path.join(logDir, '%s.%s.rqlog' % (jobName, frameName)) self.fs.create_dir(tempDir) timeMock.return_value = currentTime getTempDirMock.return_value = tempDir popenMock.return_value.returncode = returnCode rqCore = mock.MagicMock() rqCore.intervalStartTime = 20 rqCore.intervalSleepTime = 40 rqCore.machine.getTempPath.return_value = jobTempPath rqCore.machine.isDesktop.return_value = True rqCore.machine.getHostInfo.return_value = renderHost rqCore.nimby.locked = False runFrame = rqd.compiled_proto.rqd_pb2.RunFrame( frame_id=frameId, job_name=jobName, frame_name=frameName, uid=frameUid, user_name=frameUsername, log_dir=logDir) frameInfo = rqd.rqnetwork.RunningFrame(rqCore, runFrame) # when attendantThread = rqd.rqcore.FrameAttendantThread(rqCore, runFrame, frameInfo) attendantThread.start() attendantThread.join() # then permsUser.assert_called_with(frameUid, mock.ANY) popenMock.assert_called_with( [ '/usr/bin/su', frameUsername, '-c', '"' + tempDir + '/rqd-cmd-' + frameId + '-' + str(currentTime) + '"' ], env=mock.ANY, cwd=jobTempPath, stdin=mock.ANY, stdout=mock.ANY, stderr=mock.ANY, preexec_fn=mock.ANY) self.assertTrue(os.path.exists(logDir)) self.assertTrue(os.path.isfile(logFile)) _, kwargs = popenMock.call_args self.assertEqual(logFile, kwargs['stdout'].name) self.assertEqual(logFile, kwargs['stderr'].name) rqCore.network.reportRunningFrameCompletion.assert_called_with( rqd.compiled_proto.report_pb2.FrameCompleteReport( host=renderHost, frame=rqd.compiled_proto.report_pb2.RunningFrameInfo( job_name=jobName, frame_id=frameId, frame_name=frameName), exit_status=returnCode))
def requests_get(monkeypatch): mock_get = mock.MagicMock() set_response(mock_get) monkeypatch.setattr(requests, 'get', mock_get) return mock_get
MISTRAL_RUNNER_NAME = 'mistral_v2' TEST_PACK = 'mistral_tests' TEST_PACK_PATH = fixturesloader.get_fixtures_packs_base_path() + '/' + TEST_PACK PACKS = [ TEST_PACK_PATH, fixturesloader.get_fixtures_packs_base_path() + '/core' ] NON_EMPTY_RESULT = 'non-empty' @mock.patch.object( CUDPublisher, 'publish_update', mock.MagicMock(return_value=None)) @mock.patch.object( CUDPublisher, 'publish_create', mock.MagicMock(side_effect=MockLiveActionPublisher.publish_create)) @mock.patch.object( LiveActionPublisher, 'publish_state', mock.MagicMock(side_effect=MockLiveActionPublisher.publish_state)) class MistralRunnerCallbackTest(DbTestCase): @classmethod def setUpClass(cls): super(MistralRunnerCallbackTest, cls).setUpClass() # Override the retry configuration here otherwise st2tests.config.parse_args
class MistralRunnerCallbackTest(DbTestCase): @classmethod def setUpClass(cls): super(MistralRunnerCallbackTest, cls).setUpClass() # Override the retry configuration here otherwise st2tests.config.parse_args # in DbTestCase.setUpClass will reset these overrides. cfg.CONF.set_override('retry_exp_msec', 100, group='mistral') cfg.CONF.set_override('retry_exp_max_msec', 200, group='mistral') cfg.CONF.set_override('retry_stop_max_msec', 200, group='mistral') cfg.CONF.set_override('api_url', 'http://0.0.0.0:9101', group='auth') # Register runners. runnersregistrar.register_runners() # Register test pack(s). actions_registrar = actionsregistrar.ActionsRegistrar( use_pack_cache=False, fail_on_failure=True ) for pack in PACKS: actions_registrar.register_from_pack(pack) # Get an instance of the callback module and reference to mistral status map cls.callback_module = loader.register_callback_module(MISTRAL_RUNNER_NAME) cls.callback_class = cls.callback_module.get_instance() cls.status_map = cls.callback_module.STATUS_MAP @classmethod def get_runner_class(cls, runner_name): return runners.get_runner(runner_name).__class__ def test_callback_handler_status_map(self): # Ensure all StackStorm status are mapped otherwise leads to zombie workflow. self.assertListEqual(sorted(self.status_map.keys()), sorted(action_constants.LIVEACTION_STATUSES)) @mock.patch.object( action_executions.ActionExecutionManager, 'update', mock.MagicMock(return_value=None)) def test_callback_handler_with_result_as_text(self): self.callback_class.callback('http://127.0.0.1:8989/v2/action_executions/12345', {}, action_constants.LIVEACTION_STATUS_SUCCEEDED, '<html></html>') @mock.patch.object( action_executions.ActionExecutionManager, 'update', mock.MagicMock(return_value=None)) def test_callback_handler_with_result_as_dict(self): self.callback_class.callback('http://127.0.0.1:8989/v2/action_executions/12345', {}, action_constants.LIVEACTION_STATUS_SUCCEEDED, {'a': 1}) @mock.patch.object( action_executions.ActionExecutionManager, 'update', mock.MagicMock(return_value=None)) def test_callback_handler_with_result_as_json_str(self): self.callback_class.callback('http://127.0.0.1:8989/v2/action_executions/12345', {}, action_constants.LIVEACTION_STATUS_SUCCEEDED, '{"a": 1}') self.callback_class.callback('http://127.0.0.1:8989/v2/action_executions/12345', {}, action_constants.LIVEACTION_STATUS_SUCCEEDED, "{'a': 1}") @mock.patch.object( action_executions.ActionExecutionManager, 'update', mock.MagicMock(return_value=None)) def test_callback_handler_with_result_as_list(self): self.callback_class.callback('http://127.0.0.1:8989/v2/action_executions/12345', {}, action_constants.LIVEACTION_STATUS_SUCCEEDED, ["a", "b", "c"]) @mock.patch.object( action_executions.ActionExecutionManager, 'update', mock.MagicMock(return_value=None)) def test_callback_handler_with_result_as_list_str(self): self.callback_class.callback('http://127.0.0.1:8989/v2/action_executions/12345', {}, action_constants.LIVEACTION_STATUS_SUCCEEDED, '["a", "b", "c"]') @mock.patch.object( action_executions.ActionExecutionManager, 'update', mock.MagicMock(return_value=None)) def test_callback(self): local_runner_cls = self.get_runner_class('local_runner') liveaction = LiveActionDB( action='core.local', parameters={'cmd': 'uname -a'}, callback={ 'source': MISTRAL_RUNNER_NAME, 'url': 'http://127.0.0.1:8989/v2/action_executions/12345' } ) for status in action_constants.LIVEACTION_COMPLETED_STATES: expected_mistral_status = self.status_map[status] local_runner_cls.run = mock.Mock(return_value=(status, NON_EMPTY_RESULT, None)) liveaction, execution = action_service.request(liveaction) liveaction = LiveAction.get_by_id(str(liveaction.id)) self.assertEqual(liveaction.status, status) action_executions.ActionExecutionManager.update.assert_called_with( '12345', state=expected_mistral_status, output=NON_EMPTY_RESULT) @mock.patch.object( action_executions.ActionExecutionManager, 'update', mock.MagicMock(return_value=None)) def test_callback_incomplete_state(self): local_runner_cls = self.get_runner_class('local_runner') local_run_result = (action_constants.LIVEACTION_STATUS_RUNNING, NON_EMPTY_RESULT, None) local_runner_cls.run = mock.Mock(return_value=local_run_result) liveaction = LiveActionDB( action='core.local', parameters={'cmd': 'uname -a'}, callback={ 'source': MISTRAL_RUNNER_NAME, 'url': 'http://127.0.0.1:8989/v2/action_executions/12345' } ) liveaction, execution = action_service.request(liveaction) liveaction = LiveAction.get_by_id(str(liveaction.id)) self.assertEqual(liveaction.status, action_constants.LIVEACTION_STATUS_RUNNING) self.assertFalse(action_executions.ActionExecutionManager.update.called) @mock.patch.object( action_executions.ActionExecutionManager, 'update', mock.MagicMock(side_effect=[ requests.exceptions.ConnectionError(), None])) def test_callback_retry(self): local_runner_cls = self.get_runner_class('local_runner') local_run_result = (action_constants.LIVEACTION_STATUS_SUCCEEDED, NON_EMPTY_RESULT, None) local_runner_cls.run = mock.Mock(return_value=local_run_result) liveaction = LiveActionDB( action='core.local', parameters={'cmd': 'uname -a'}, callback={ 'source': MISTRAL_RUNNER_NAME, 'url': 'http://127.0.0.1:8989/v2/action_executions/12345' } ) liveaction, execution = action_service.request(liveaction) liveaction = LiveAction.get_by_id(str(liveaction.id)) self.assertEqual(liveaction.status, action_constants.LIVEACTION_STATUS_SUCCEEDED) calls = [call('12345', state='SUCCESS', output=NON_EMPTY_RESULT) for i in range(0, 2)] action_executions.ActionExecutionManager.update.assert_has_calls(calls) @mock.patch.object( action_executions.ActionExecutionManager, 'update', mock.MagicMock(side_effect=[ requests.exceptions.ConnectionError(), requests.exceptions.ConnectionError(), requests.exceptions.ConnectionError(), requests.exceptions.ConnectionError(), None])) def test_callback_retry_exhausted(self): local_runner_cls = self.get_runner_class('local_runner') local_run_result = (action_constants.LIVEACTION_STATUS_SUCCEEDED, NON_EMPTY_RESULT, None) local_runner_cls.run = mock.Mock(return_value=local_run_result) liveaction = LiveActionDB( action='core.local', parameters={'cmd': 'uname -a'}, callback={ 'source': MISTRAL_RUNNER_NAME, 'url': 'http://127.0.0.1:8989/v2/action_executions/12345' } ) liveaction, execution = action_service.request(liveaction) liveaction = LiveAction.get_by_id(str(liveaction.id)) self.assertEqual(liveaction.status, action_constants.LIVEACTION_STATUS_SUCCEEDED) # This test initially setup mock for action_executions.ActionExecutionManager.update # to fail the first 4 times and return success on the 5th times. The max attempts # is set to 3. We expect only 3 calls to pass thru the update method. calls = [call('12345', state='SUCCESS', output=NON_EMPTY_RESULT) for i in range(0, 2)] action_executions.ActionExecutionManager.update.assert_has_calls(calls)
def setUp(self): common.HeatTestCase.setUp(self) self.rpc_client = mock.MagicMock()
def mock_node(uuid, uri): node = mock.MagicMock() node.vios_uuid = uuid node.vios_uri = uri return node
def settings(self): return { 'github': mock.MagicMock(), 'roboto_url': 'http://jenkins.plone.org/roboto', }
def setUp(self): super(SyncPointTestCase, self).setUp() self.dummy_event = mock.MagicMock() self.dummy_event.ready.return_value = False
def setUp(self): super(TestMonascaPublisher, self).setUp() self.CONF = self.useFixture(fixture_config.Config()).conf self.CONF([], project='ceilometer', validate_default_values=True) self.parsed_url = mock.MagicMock() ksclient.KSClient = mock.MagicMock()
def test_storeFrameDuplicate(self): frame_id = 'arbitrary-frame-id' self.rqcore.storeFrame(frame_id, mock.MagicMock(spec=rqd.rqnetwork.RunningFrame)) with self.assertRaises(rqd.rqexceptions.RqdException): self.rqcore.storeFrame(frame_id, mock.MagicMock(spec=rqd.rqnetwork.RunningFrame))
def setUp(self): super(TestDumpACPITable, self).setUp() self.chipsec_mock.hal.acpi = mock.MagicMock() self.chipsec_mock.hal.acpi.ACPI = MockACPI self.grr_chipsec_module.acpi = self.chipsec_mock.hal.acpi
class RqCoreTests(unittest.TestCase): @mock.patch('rqd.rqnimby.Nimby', autospec=True) @mock.patch('rqd.rqnetwork.Network', autospec=True) @mock.patch('rqd.rqmachine.Machine', autospec=True) def setUp(self, machineMock, networkMock, nimbyMock): self.machineMock = machineMock self.networkMock = networkMock self.nimbyMock = nimbyMock self.rqcore = rqd.rqcore.RqCore() @mock.patch.object(rqd.rqcore.RqCore, 'nimbyOn') def test_startServer(self, nimbyOnMock): rqd.rqconstants.OVERRIDE_NIMBY = False self.machineMock.return_value.isDesktop.return_value = False self.rqcore.start() self.networkMock.return_value.start_grpc.assert_called() nimbyOnMock.assert_not_called() @mock.patch.object(rqd.rqcore.RqCore, 'nimbyOn', autospec=True) def test_startServerWithNimby(self, nimbyOnMock): rqd.rqconstants.OVERRIDE_NIMBY = True self.machineMock.return_value.isDesktop.return_value = False self.rqcore.start() self.networkMock.return_value.start_grpc.assert_called() nimbyOnMock.assert_called_with(self.rqcore) @mock.patch.object(rqd.rqcore.RqCore, 'nimbyOn', autospec=True) def test_startDesktopNimbyOn(self, nimbyOnMock): rqd.rqconstants.OVERRIDE_NIMBY = True self.machineMock.return_value.isDesktop.return_value = True self.rqcore.start() self.networkMock.return_value.start_grpc.assert_called() nimbyOnMock.assert_called_with(self.rqcore) @mock.patch.object(rqd.rqcore.RqCore, 'nimbyOn') def test_startDesktopNimbyOff(self, nimbyOnMock): rqd.rqconstants.OVERRIDE_NIMBY = False self.machineMock.return_value.isDesktop.return_value = True self.rqcore.start() self.networkMock.return_value.start_grpc.assert_called() nimbyOnMock.assert_not_called() @mock.patch.object(rqd.rqcore.RqCore, 'nimbyOn') def test_startDesktopNimbyUndefined(self, nimbyOnMock): rqd.rqconstants.OVERRIDE_NIMBY = None self.machineMock.return_value.isDesktop.return_value = True self.rqcore.start() self.networkMock.return_value.start_grpc.assert_called() nimbyOnMock.assert_not_called() @mock.patch('rqd.rqnetwork.Network', autospec=True) @mock.patch('rqd.rqmachine.Machine', autospec=True) @mock.patch.object(rqd.rqcore.RqCore, 'nimbyOn') def test_startDesktopNimbyOffWithFlag(self, nimbyOnMock, machineMock, networkMock): rqd.rqconstants.OVERRIDE_NIMBY = True machineMock.return_value.isDesktop.return_value = True rqcore = rqd.rqcore.RqCore(optNimbyoff=True) rqcore.start() networkMock.return_value.start_grpc.assert_called() nimbyOnMock.assert_not_called() @mock.patch('threading.Timer') def test_grpcConnected(self, timerMock): update_rss_thread = mock.MagicMock() interval_thread = mock.MagicMock() timerMock.side_effect = [update_rss_thread, interval_thread] self.rqcore.grpcConnected() self.networkMock.return_value.reportRqdStartup.assert_called() update_rss_thread.start.assert_called() interval_thread.start.assert_called() @mock.patch.object(rqd.rqcore.RqCore, 'sendStatusReport', autospec=True) @mock.patch('threading.Timer') def test_onInterval(self, timerMock, sendStatusReportMock): self.rqcore.onInterval() timerMock.return_value.start.assert_called() sendStatusReportMock.assert_called_with(self.rqcore) @mock.patch('threading.Timer', autospec=True) def test_onIntervalWithSleepTime(self, timerMock): sleep_time = 72 self.rqcore.onInterval(sleepTime=sleep_time) timerMock.assert_called_with(sleep_time, mock.ANY) timerMock.return_value.start.assert_called() @mock.patch.object(rqd.rqcore.RqCore, 'shutdownRqdNow') @mock.patch('threading.Timer', new=mock.MagicMock()) def test_onIntervalShutdown(self, shutdownRqdNowMock): self.rqcore.shutdownRqdIdle() self.machineMock.return_value.isUserLoggedIn.return_value = False shutdownRqdNowMock.reset_mock() shutdownRqdNowMock.assert_not_called() self.rqcore.onInterval() shutdownRqdNowMock.assert_called_with() @mock.patch('threading.Timer') def test_updateRss(self, timerMock): self.rqcore.storeFrame('frame-id', mock.MagicMock(spec=rqd.rqnetwork.RunningFrame)) self.rqcore.updateRss() self.machineMock.return_value.rssUpdate.assert_called() timerMock.return_value.start.assert_called() def test_getFrame(self): frame_id = 'arbitrary-frame-id' frame = mock.MagicMock(spec=rqd.rqnetwork.RunningFrame) self.rqcore.storeFrame(frame_id, frame) self.assertEqual(frame, self.rqcore.getFrame(frame_id)) def test_getFrameKeys(self): frame_ids = ['frame1', 'frame2'] self.rqcore.storeFrame(frame_ids[0], mock.MagicMock(spec=rqd.rqnetwork.RunningFrame)) self.rqcore.storeFrame(frame_ids[1], mock.MagicMock(spec=rqd.rqnetwork.RunningFrame)) self.assertEqual(set(frame_ids), set(self.rqcore.getFrameKeys())) def test_storeFrame(self): frame_id = 'arbitrary-frame-id' frame = mock.MagicMock(spec=rqd.rqnetwork.RunningFrame) with self.assertRaises(KeyError): self.rqcore.getFrame(frame_id) self.rqcore.storeFrame(frame_id, frame) self.assertEqual(frame, self.rqcore.getFrame(frame_id)) def test_storeFrameDuplicate(self): frame_id = 'arbitrary-frame-id' self.rqcore.storeFrame(frame_id, mock.MagicMock(spec=rqd.rqnetwork.RunningFrame)) with self.assertRaises(rqd.rqexceptions.RqdException): self.rqcore.storeFrame(frame_id, mock.MagicMock(spec=rqd.rqnetwork.RunningFrame)) def test_deleteFrame(self): frame_id = 'arbitrary-frame-id' frame = mock.MagicMock(spec=rqd.rqnetwork.RunningFrame) self.rqcore.storeFrame(frame_id, frame) self.rqcore.deleteFrame(frame_id) self.rqcore.deleteFrame('unknown-key-should-succeed') with self.assertRaises(KeyError): self.rqcore.getFrame(frame_id) def test_killAllFrame(self): frameAttendantThread = mock.MagicMock() frameAttendantThread.isAlive.return_value = False frame1Id = 'frame1' frame2Id = 'frame2' frame3Id = 'frame3' frame1 = rqd.rqnetwork.RunningFrame( self.rqcore, rqd.compiled_proto.rqd_pb2.RunFrame(frame_id=frame1Id)) frame1.frameAttendantThread = frameAttendantThread frame2 = rqd.rqnetwork.RunningFrame( self.rqcore, rqd.compiled_proto.rqd_pb2.RunFrame(frame_id=frame2Id)) frame2.frameAttendantThread = frameAttendantThread frame3 = rqd.rqnetwork.RunningFrame( self.rqcore, rqd.compiled_proto.rqd_pb2.RunFrame(frame_id=frame3Id)) frame3.frameAttendantThread = frameAttendantThread self.rqcore.storeFrame(frame1Id, frame1) self.rqcore.storeFrame(frame2Id, frame2) self.rqcore.storeFrame(frame3Id, frame3) # There's no result to verify here; if the method completes successfully # it means that all frames were properly killed, as the method won't finish # until its frame cache is cleared by the kill process. self.rqcore.killAllFrame('arbitrary reason') def test_killAllFrameIgnoreNimby(self): frameAttendantThread = mock.MagicMock() frameAttendantThread.isAlive.return_value = False frame1Id = 'frame1' frame2Id = 'frame2' frame1 = rqd.rqnetwork.RunningFrame( self.rqcore, rqd.compiled_proto.rqd_pb2.RunFrame(frame_id=frame1Id)) frame1.frameAttendantThread = frameAttendantThread frame2 = rqd.rqnetwork.RunningFrame( self.rqcore, rqd.compiled_proto.rqd_pb2.RunFrame(frame_id=frame2Id, ignore_nimby=True)) frame2.frameAttendantThread = frameAttendantThread self.rqcore.storeFrame(frame1Id, frame1) self.rqcore.storeFrame(frame2Id, frame2) self.rqcore.killAllFrame('NIMBY related reason') self.assertEqual(frame2, self.rqcore.getFrame(frame2Id)) def test_releaseCores(self): num_idle_cores = 10 num_booked_cores = 7 num_cores_to_release = 5 self.rqcore.cores = rqd.compiled_proto.report_pb2.CoreDetail( total_cores=50, idle_cores=num_idle_cores, locked_cores=2, booked_cores=num_booked_cores) self.rqcore.releaseCores(num_cores_to_release) self.assertEqual(num_booked_cores-num_cores_to_release, self.rqcore.cores.booked_cores) self.assertEqual(num_idle_cores+num_cores_to_release, self.rqcore.cores.idle_cores) @mock.patch.object(rqd.rqcore.RqCore, 'nimbyOff') def test_shutdown(self, nimbyOffMock): self.rqcore.onIntervalThread = mock.MagicMock() self.rqcore.updateRssThread = mock.MagicMock() self.rqcore.shutdown() nimbyOffMock.assert_called() self.rqcore.onIntervalThread.cancel.assert_called() self.rqcore.updateRssThread.cancel.assert_called() @mock.patch('rqd.rqnetwork.Network', autospec=True) @mock.patch('sys.exit') def test_handleExit(self, networkMock, exitMock): self.rqcore = rqd.rqcore.RqCore() self.rqcore.handleExit(None, None) exitMock.assert_called() @mock.patch('rqd.rqcore.FrameAttendantThread') def test_launchFrame(self, frameThreadMock): self.rqcore.cores = rqd.compiled_proto.report_pb2.CoreDetail(total_cores=100, idle_cores=20) self.machineMock.return_value.state = rqd.compiled_proto.host_pb2.UP self.nimbyMock.return_value.locked = False frame = rqd.compiled_proto.rqd_pb2.RunFrame(uid=22, num_cores=10) self.rqcore.launchFrame(frame) frameThreadMock.return_value.start.assert_called() def test_launchFrameOnDownHost(self): self.machineMock.return_value.state = rqd.compiled_proto.host_pb2.DOWN frame = rqd.compiled_proto.rqd_pb2.RunFrame() with self.assertRaises(rqd.rqexceptions.CoreReservationFailureException): self.rqcore.launchFrame(frame) def test_launchFrameOnHostWaitingForShutdown(self): self.machineMock.return_value.state = rqd.compiled_proto.host_pb2.UP self.nimbyMock.return_value.active = False frame = rqd.compiled_proto.rqd_pb2.RunFrame() self.rqcore.shutdownRqdIdle() with self.assertRaises(rqd.rqexceptions.CoreReservationFailureException): self.rqcore.launchFrame(frame) @mock.patch('rqd.rqcore.FrameAttendantThread') def test_launchFrameOnNimbyHost(self, frameThreadMock): self.rqcore.cores = rqd.compiled_proto.report_pb2.CoreDetail(total_cores=100, idle_cores=20) self.machineMock.return_value.state = rqd.compiled_proto.host_pb2.UP frame = rqd.compiled_proto.rqd_pb2.RunFrame(uid=22, num_cores=10) frameIgnoreNimby = rqd.compiled_proto.rqd_pb2.RunFrame( uid=22, num_cores=10, ignore_nimby=True) self.rqcore.nimby = mock.create_autospec(rqd.rqnimby.Nimby) self.rqcore.nimby.locked = True with self.assertRaises(rqd.rqexceptions.CoreReservationFailureException): self.rqcore.launchFrame(frame) self.rqcore.launchFrame(frameIgnoreNimby) frameThreadMock.return_value.start.assert_called() def test_launchDuplicateFrame(self): self.rqcore.cores = rqd.compiled_proto.report_pb2.CoreDetail(total_cores=100, idle_cores=20) self.machineMock.return_value.state = rqd.compiled_proto.host_pb2.UP self.nimbyMock.return_value.locked = False frameId = 'arbitrary-frame-id' self.rqcore.storeFrame(frameId, rqd.compiled_proto.rqd_pb2.RunFrame(frame_id=frameId)) frameToLaunch = rqd.compiled_proto.rqd_pb2.RunFrame(frame_id=frameId) with self.assertRaises(rqd.rqexceptions.DuplicateFrameViolationException): self.rqcore.launchFrame(frameToLaunch) def test_launchFrameWithInvalidUid(self): self.machineMock.return_value.state = rqd.compiled_proto.host_pb2.UP self.nimbyMock.return_value.locked = False frame = rqd.compiled_proto.rqd_pb2.RunFrame(uid=0) with self.assertRaises(rqd.rqexceptions.InvalidUserException): self.rqcore.launchFrame(frame) def test_launchFrameWithInvalidCoreCount(self): self.machineMock.return_value.state = rqd.compiled_proto.host_pb2.UP self.nimbyMock.return_value.locked = False frame = rqd.compiled_proto.rqd_pb2.RunFrame(uid=22, num_cores=0) with self.assertRaises(rqd.rqexceptions.CoreReservationFailureException): self.rqcore.launchFrame(frame) def test_launchFrameWithInsufficientCores(self): self.rqcore.cores = rqd.compiled_proto.report_pb2.CoreDetail(total_cores=100, idle_cores=5) self.machineMock.return_value.state = rqd.compiled_proto.host_pb2.UP self.nimbyMock.return_value.locked = False frame = rqd.compiled_proto.rqd_pb2.RunFrame(uid=22, num_cores=10) with self.assertRaises(rqd.rqexceptions.CoreReservationFailureException): self.rqcore.launchFrame(frame) def test_getRunningFrame(self): frameId = 'arbitrary-frame-id' frame = rqd.compiled_proto.rqd_pb2.RunFrame(frame_id=frameId) self.rqcore.storeFrame(frameId, frame) self.assertEqual(frame, self.rqcore.getRunningFrame(frameId)) self.assertIsNone(self.rqcore.getRunningFrame('some-unknown-frame-id')) @mock.patch.object(rqd.rqcore.RqCore, 'respawn_rqd', autospec=True) def test_restartRqdNowNoFrames(self, respawnMock): self.nimbyMock.return_value.active = False self.rqcore.restartRqdNow() respawnMock.assert_called_with(self.rqcore) @mock.patch.object(rqd.rqcore.RqCore, 'killAllFrame', autospec=True) def test_restartRqdNowWithFrames(self, killAllFrameMock): frame1Id = 'frame1' frame1 = rqd.rqnetwork.RunningFrame( self.rqcore, rqd.compiled_proto.rqd_pb2.RunFrame(frame_id=frame1Id)) self.rqcore.storeFrame(frame1Id, frame1) self.rqcore.restartRqdNow() killAllFrameMock.assert_called_with(self.rqcore, mock.ANY) @mock.patch.object(rqd.rqcore.RqCore, 'respawn_rqd', autospec=True) def test_restartRqdIdleNoFrames(self, respawnMock): self.nimbyMock.return_value.active = False self.rqcore.restartRqdIdle() respawnMock.assert_called_with(self.rqcore) @mock.patch.object(rqd.rqcore.RqCore, 'respawn_rqd') def test_restartRqdIdleWithFrames(self, respawnMock): frame1Id = 'frame1' frame1 = rqd.rqnetwork.RunningFrame( self.rqcore, rqd.compiled_proto.rqd_pb2.RunFrame(frame_id=frame1Id)) self.rqcore.storeFrame(frame1Id, frame1) self.rqcore.restartRqdIdle() self.assertTrue(self.rqcore.isWaitingForIdle()) respawnMock.assert_not_called() def test_rebootNowNoUser(self): self.machineMock.return_value.isUserLoggedIn.return_value = False self.nimbyMock.return_value.active = False self.rqcore.rebootNow() self.machineMock.return_value.reboot.assert_called_with() def test_rebootNowWithUser(self): self.machineMock.return_value.isUserLoggedIn.return_value = True with self.assertRaises(rqd.rqexceptions.RqdException): self.rqcore.rebootNow() def test_rebootIdleNoFrames(self): self.machineMock.return_value.isUserLoggedIn.return_value = False self.nimbyMock.return_value.active = False self.rqcore.rebootIdle() self.machineMock.return_value.reboot.assert_called_with() def test_rebootIdleWithFrames(self): frame1Id = 'frame1' frame1 = rqd.rqnetwork.RunningFrame( self.rqcore, rqd.compiled_proto.rqd_pb2.RunFrame(frame_id=frame1Id)) self.rqcore.storeFrame(frame1Id, frame1) self.rqcore.rebootIdle() self.assertTrue(self.rqcore.isWaitingForIdle()) self.machineMock.return_value.reboot.assert_not_called() @mock.patch('os.getuid', new=mock.MagicMock(return_value=0)) @mock.patch('platform.system', new=mock.MagicMock(return_value='Linux')) def test_nimbyOn(self): self.nimbyMock.return_value.active = False self.rqcore.nimbyOn() self.nimbyMock.return_value.run.assert_called_with() def test_nimbyOff(self): self.nimbyMock.return_value.active = True self.rqcore.nimbyOff() self.nimbyMock.return_value.stop.assert_called_with() @mock.patch.object(rqd.rqcore.RqCore, 'killAllFrame', autospec=True) def test_onNimbyLock(self, killAllFrameMock): self.rqcore.onNimbyLock() killAllFrameMock.assert_called_with(self.rqcore, mock.ANY) @mock.patch.object(rqd.rqcore.RqCore, 'sendStatusReport', autospec=True) def test_onNimbyUnlock(self, sendStatusReportMock): self.rqcore.onNimbyUnlock() sendStatusReportMock.assert_called_with(self.rqcore) def test_lock(self): self.rqcore.cores.total_cores = 50 self.rqcore.cores.idle_cores = 40 self.rqcore.cores.locked_cores = 10 self.rqcore.lock(20) self.assertEqual(20, self.rqcore.cores.idle_cores) self.assertEqual(30, self.rqcore.cores.locked_cores) def test_lockMoreCoresThanThereAre(self): self.rqcore.cores.total_cores = 50 self.rqcore.cores.idle_cores = 40 self.rqcore.cores.locked_cores = 10 self.rqcore.lock(100) self.assertEqual(0, self.rqcore.cores.idle_cores) self.assertEqual(50, self.rqcore.cores.locked_cores) def test_lockAll(self): self.rqcore.cores.total_cores = 50 self.rqcore.cores.idle_cores = 40 self.rqcore.cores.locked_cores = 10 self.rqcore.lockAll() self.assertEqual(0, self.rqcore.cores.idle_cores) self.assertEqual(50, self.rqcore.cores.locked_cores) def test_unlock(self): self.machineMock.return_value.state = rqd.compiled_proto.host_pb2.UP self.rqcore.cores.total_cores = 50 self.rqcore.cores.idle_cores = 10 self.rqcore.cores.locked_cores = 40 self.rqcore.unlock(20) self.assertEqual(30, self.rqcore.cores.idle_cores) self.assertEqual(20, self.rqcore.cores.locked_cores) def test_unlockMoreCoresThanThereAre(self): self.machineMock.return_value.state = rqd.compiled_proto.host_pb2.UP self.rqcore.cores.total_cores = 50 self.rqcore.cores.idle_cores = 40 self.rqcore.cores.locked_cores = 10 self.rqcore.unlock(100) self.assertEqual(50, self.rqcore.cores.idle_cores) self.assertEqual(0, self.rqcore.cores.locked_cores) def test_unlockAll(self): self.machineMock.return_value.state = rqd.compiled_proto.host_pb2.UP self.nimbyMock.return_value.locked = False self.rqcore.cores.total_cores = 50 self.rqcore.cores.idle_cores = 40 self.rqcore.cores.locked_cores = 10 self.rqcore.unlockAll() self.assertEqual(50, self.rqcore.cores.idle_cores) self.assertEqual(0, self.rqcore.cores.locked_cores) def test_unlockAllWhenNimbyLocked(self): self.machineMock.return_value.state = rqd.compiled_proto.host_pb2.UP self.nimbyMock.return_value.locked = True self.rqcore.cores.total_cores = 50 self.rqcore.cores.idle_cores = 40 self.rqcore.cores.locked_cores = 10 self.rqcore.unlockAll() self.assertEqual(40, self.rqcore.cores.idle_cores) self.assertEqual(0, self.rqcore.cores.locked_cores)
def setUp(self): super(TestChipsecDumpFlashImage, self).setUp() self.chipsec_mock.hal.spi = mock.MagicMock() self.chipsec_mock.hal.spi.SPI = MockSPI self.grr_chipsec_module.spi = self.chipsec_mock.hal.spi
def patch_time_module(monkeypatch): mock_time = mock.MagicMock() mock_time.return_value = test_nonce / 1000 monkeypatch.setattr(time, 'time', mock_time)
def test__download_image_from_url_failure(self, status_code, mock_get): self.mock_isfile.return_value = False mock_get.return_value = mock.MagicMock(status_code=status_code) self.assertRaises(exceptions.RallyException, self.context._download_image_from_source, os.path.join(self.context.data_dir, "foo"))
def requests_post(monkeypatch): mock_post = mock.MagicMock() set_response(mock_post) monkeypatch.setattr(requests, 'post', mock_post) return mock_post
class TempestContextTestCase(test.TestCase): def setUp(self): super(TempestContextTestCase, self).setUp() mock.patch("rally.osclients.Clients").start() self.mock_isfile = mock.patch("os.path.isfile", return_value=True).start() self.deployment = fakes.FakeDeployment(**CREDS) cfg = {"verifier": mock.Mock(deployment=self.deployment), "verification": {"uuid": "uuid"}} cfg["verifier"].manager.home_dir = "/p/a/t/h" cfg["verifier"].manager.configfile = "/fake/path/to/config" self.context = context.TempestContext(cfg) self.context.conf.add_section("compute") self.context.conf.add_section("orchestration") self.context.conf.add_section("scenario") @mock.patch("six.moves.builtins.open", side_effect=mock.mock_open(), create=True) def test__download_image_from_glance(self, mock_open): self.mock_isfile.return_value = False img_path = os.path.join(self.context.data_dir, "foo") img = mock.MagicMock() glanceclient = self.context.clients.glance() glanceclient.images.data.return_value = "data" self.context._download_image_from_source(img_path, img) mock_open.assert_called_once_with(img_path, "wb") glanceclient.images.data.assert_called_once_with(img.id) mock_open().write.assert_has_calls([mock.call("d"), mock.call("a"), mock.call("t"), mock.call("a")]) @mock.patch("six.moves.builtins.open", side_effect=mock.mock_open()) @mock.patch("requests.get", return_value=mock.MagicMock(status_code=200)) def test__download_image_from_url_success(self, mock_get, mock_open): self.mock_isfile.return_value = False img_path = os.path.join(self.context.data_dir, "foo") mock_get.return_value.iter_content.return_value = "data" self.context._download_image_from_source(img_path) mock_get.assert_called_once_with(CONF.tempest.img_url, stream=True) mock_open.assert_called_once_with(img_path, "wb") mock_open().write.assert_has_calls([mock.call("d"), mock.call("a"), mock.call("t"), mock.call("a")]) @mock.patch("requests.get") @ddt.data(404, 500) def test__download_image_from_url_failure(self, status_code, mock_get): self.mock_isfile.return_value = False mock_get.return_value = mock.MagicMock(status_code=status_code) self.assertRaises(exceptions.RallyException, self.context._download_image_from_source, os.path.join(self.context.data_dir, "foo")) @mock.patch("requests.get", side_effect=requests.ConnectionError()) def test__download_image_from_url_connection_error( self, mock_requests_get): self.mock_isfile.return_value = False self.assertRaises(exceptions.RallyException, self.context._download_image_from_source, os.path.join(self.context.data_dir, "foo")) @mock.patch("rally.plugins.openstack.wrappers." "network.NeutronWrapper.create_network") @mock.patch("six.moves.builtins.open", side_effect=mock.mock_open()) def test_options_configured_manually( self, mock_open, mock_neutron_wrapper_create_network): self.context.available_services = ["glance", "heat", "nova", "neutron"] self.context.conf.set("compute", "image_ref", "id1") self.context.conf.set("compute", "image_ref_alt", "id2") self.context.conf.set("compute", "flavor_ref", "id3") self.context.conf.set("compute", "flavor_ref_alt", "id4") self.context.conf.set("compute", "fixed_network_name", "name1") self.context.conf.set("orchestration", "instance_type", "id5") self.context.conf.set("scenario", "img_file", "id6") self.context.__enter__() glanceclient = self.context.clients.glance() novaclient = self.context.clients.nova() self.assertEqual(glanceclient.images.create.call_count, 0) self.assertEqual(novaclient.flavors.create.call_count, 0) self.assertEqual(mock_neutron_wrapper_create_network.call_count, 0) def test__create_tempest_roles(self): role1 = CONF.tempest.swift_operator_role role2 = CONF.tempest.swift_reseller_admin_role role3 = CONF.tempest.heat_stack_owner_role role4 = CONF.tempest.heat_stack_user_role client = self.context.clients.verified_keystone() client.roles.list.return_value = [fakes.FakeRole(name=role1), fakes.FakeRole(name=role2)] client.roles.create.side_effect = [fakes.FakeFlavor(name=role3), fakes.FakeFlavor(name=role4)] self.context._create_tempest_roles() self.assertEqual(client.roles.create.call_count, 2) created_roles = [role.name for role in self.context._created_roles] self.assertIn(role3, created_roles) self.assertIn(role4, created_roles) @mock.patch("rally.plugins.openstack.wrappers.glance.wrap") def test__discover_image(self, mock_wrap): client = mock_wrap.return_value client.list_images.return_value = [fakes.FakeImage(name="Foo"), fakes.FakeImage(name="CirrOS")] image = self.context._discover_image() self.assertEqual("CirrOS", image.name) @mock.patch("six.moves.builtins.open", side_effect=mock.mock_open(), create=True) @mock.patch("rally.plugins.openstack.wrappers.glance.wrap") @mock.patch("os.path.isfile", return_value=False) def test__download_image(self, mock_isfile, mock_wrap, mock_open): img_1 = mock.MagicMock() img_1.name = "Foo" img_2 = mock.MagicMock() img_2.name = "CirrOS" glanceclient = self.context.clients.glance() glanceclient.images.data.return_value = "data" mock_wrap.return_value.list_images.return_value = [img_1, img_2] self.context._download_image() img_path = os.path.join(self.context.data_dir, self.context.image_name) mock_wrap.return_value.list_images.assert_called_once_with( status="active", visibility="public") glanceclient.images.data.assert_called_once_with(img_2.id) mock_open.assert_called_once_with(img_path, "wb") mock_open().write.assert_has_calls([mock.call("d"), mock.call("a"), mock.call("t"), mock.call("a")]) # We can choose any option to test the '_configure_option' method. So let's # configure the 'flavor_ref' option. def test__configure_option(self): helper_method = mock.MagicMock() helper_method.side_effect = [fakes.FakeFlavor(id="id1")] self.context.conf.set("compute", "flavor_ref", "") self.context._configure_option("compute", "flavor_ref", helper_method=helper_method, flv_ram=64) self.assertEqual(helper_method.call_count, 1) result = self.context.conf.get("compute", "flavor_ref") self.assertEqual("id1", result) @mock.patch("rally.plugins.openstack.wrappers.glance.wrap") def test__discover_or_create_image_when_image_exists(self, mock_wrap): client = mock_wrap.return_value client.list_images.return_value = [fakes.FakeImage(name="CirrOS")] image = self.context._discover_or_create_image() self.assertEqual("CirrOS", image.name) self.assertEqual(0, client.create_image.call_count) self.assertEqual(0, len(self.context._created_images)) @mock.patch("rally.plugins.openstack.wrappers.glance.wrap") def test__discover_or_create_image(self, mock_wrap): client = mock_wrap.return_value image = self.context._discover_or_create_image() self.assertEqual(image, client.create_image.return_value) self.assertEqual(self.context._created_images[0], client.create_image.return_value) client.create_image.assert_called_once_with( container_format=CONF.tempest.img_container_format, image_location=mock.ANY, disk_format=CONF.tempest.img_disk_format, name=mock.ANY, visibility="public") def test__discover_or_create_flavor_when_flavor_exists(self): client = self.context.clients.nova() client.flavors.list.return_value = [fakes.FakeFlavor(id="id1", ram=64, vcpus=1, disk=0)] flavor = self.context._discover_or_create_flavor(64) self.assertEqual("id1", flavor.id) self.assertEqual(0, len(self.context._created_flavors)) def test__discover_or_create_flavor(self): client = self.context.clients.nova() client.flavors.create.side_effect = [fakes.FakeFlavor(id="id1")] flavor = self.context._discover_or_create_flavor(64) self.assertEqual("id1", flavor.id) self.assertEqual("id1", self.context._created_flavors[0].id) def test__create_network_resources(self): client = self.context.clients.neutron() fake_network = { "id": "nid1", "name": "network", "status": "status"} client.create_network.side_effect = [{"network": fake_network}] client.create_router.side_effect = [{"router": {"id": "rid1"}}] client.create_subnet.side_effect = [{"subnet": {"id": "subid1"}}] network = self.context._create_network_resources() self.assertEqual("nid1", network["id"]) self.assertEqual("nid1", self.context._created_networks[0]["id"]) self.assertEqual("rid1", self.context._created_networks[0]["router_id"]) self.assertEqual("subid1", self.context._created_networks[0]["subnets"][0]) def test__cleanup_tempest_roles(self): self.context._created_roles = [fakes.FakeRole(), fakes.FakeRole()] self.context._cleanup_tempest_roles() client = self.context.clients.keystone() self.assertEqual(client.roles.delete.call_count, 2) @mock.patch("rally.plugins.openstack.wrappers.glance.wrap") def test__cleanup_images(self, mock_wrap): self.context._created_images = [fakes.FakeImage(id="id1"), fakes.FakeImage(id="id2")] self.context.conf.set("compute", "image_ref", "id1") self.context.conf.set("compute", "image_ref_alt", "id2") wrapper = mock_wrap.return_value wrapper.get_image.side_effect = [ fakes.FakeImage(id="id1", status="DELETED"), fakes.FakeImage(id="id2"), fakes.FakeImage(id="id2", status="DELETED")] self.context._cleanup_images() client = self.context.clients.glance() client.images.delete.assert_has_calls([mock.call("id1"), mock.call("id2")]) self.assertEqual("", self.context.conf.get("compute", "image_ref")) self.assertEqual("", self.context.conf.get("compute", "image_ref_alt")) def test__cleanup_flavors(self): self.context._created_flavors = [fakes.FakeFlavor(id="id1"), fakes.FakeFlavor(id="id2"), fakes.FakeFlavor(id="id3")] self.context.conf.set("compute", "flavor_ref", "id1") self.context.conf.set("compute", "flavor_ref_alt", "id2") self.context.conf.set("orchestration", "instance_type", "id3") self.context._cleanup_flavors() client = self.context.clients.nova() self.assertEqual(client.flavors.delete.call_count, 3) self.assertEqual("", self.context.conf.get("compute", "flavor_ref")) self.assertEqual("", self.context.conf.get("compute", "flavor_ref_alt")) self.assertEqual("", self.context.conf.get("orchestration", "instance_type")) @mock.patch("rally.plugins.openstack.wrappers." "network.NeutronWrapper.delete_network") def test__cleanup_network_resources( self, mock_neutron_wrapper_delete_network): self.context._created_networks = [{"name": "net-12345"}] self.context.conf.set("compute", "fixed_network_name", "net-12345") self.context._cleanup_network_resources() self.assertEqual(mock_neutron_wrapper_delete_network.call_count, 1) self.assertEqual("", self.context.conf.get("compute", "fixed_network_name")) @mock.patch("six.moves.builtins.open", side_effect=mock.mock_open()) @mock.patch("%s.TempestContext._configure_option" % PATH) @mock.patch("%s.TempestContext._create_tempest_roles" % PATH) @mock.patch("rally.verification.utils.create_dir") @mock.patch("%s.osclients.Clients" % PATH) def test_setup(self, mock_clients, mock_create_dir, mock__create_tempest_roles, mock__configure_option, mock_open): self.deployment = fakes.FakeDeployment(**CREDS) verifier = mock.Mock(deployment=self.deployment) verifier.manager.home_dir = "/p/a/t/h" # case #1: no neutron and heat mock_clients.return_value.services.return_value = {} ctx = context.TempestContext({"verifier": verifier}) ctx.conf = mock.Mock() ctx.setup() ctx.conf.read.assert_called_once_with(verifier.manager.configfile) mock_create_dir.assert_called_once_with(ctx.data_dir) mock__create_tempest_roles.assert_called_once_with() mock_open.assert_called_once_with(verifier.manager.configfile, "w") ctx.conf.write(mock_open.side_effect()) self.assertEqual( [mock.call("DEFAULT", "log_file", "/p/a/t/h/tempest.log"), mock.call("oslo_concurrency", "lock_path", "/p/a/t/h/lock_files"), mock.call("scenario", "img_dir", "/p/a/t/h"), mock.call("scenario", "img_file", ctx.image_name, helper_method=ctx._download_image), mock.call("compute", "image_ref", helper_method=ctx._discover_or_create_image), mock.call("compute", "image_ref_alt", helper_method=ctx._discover_or_create_image), mock.call("compute", "flavor_ref", helper_method=ctx._discover_or_create_flavor, flv_ram=config.CONF.tempest.flavor_ref_ram), mock.call("compute", "flavor_ref_alt", helper_method=ctx._discover_or_create_flavor, flv_ram=config.CONF.tempest.flavor_ref_alt_ram)], mock__configure_option.call_args_list) mock_create_dir.reset_mock() mock__create_tempest_roles.reset_mock() mock_open.reset_mock() mock__configure_option.reset_mock() # case #2: neutron and heat are presented mock_clients.return_value.services.return_value = { "network": "neutron", "orchestration": "heat"} ctx = context.TempestContext({"verifier": verifier}) ctx.conf = mock.Mock() ctx.setup() ctx.conf.read.assert_called_once_with(verifier.manager.configfile) mock_create_dir.assert_called_once_with(ctx.data_dir) mock__create_tempest_roles.assert_called_once_with() mock_open.assert_called_once_with(verifier.manager.configfile, "w") ctx.conf.write(mock_open.side_effect()) self.assertEqual( [mock.call("DEFAULT", "log_file", "/p/a/t/h/tempest.log"), mock.call("oslo_concurrency", "lock_path", "/p/a/t/h/lock_files"), mock.call("scenario", "img_dir", "/p/a/t/h"), mock.call("scenario", "img_file", ctx.image_name, helper_method=ctx._download_image), mock.call("compute", "image_ref", helper_method=ctx._discover_or_create_image), mock.call("compute", "image_ref_alt", helper_method=ctx._discover_or_create_image), mock.call("compute", "flavor_ref", helper_method=ctx._discover_or_create_flavor, flv_ram=config.CONF.tempest.flavor_ref_ram), mock.call("compute", "flavor_ref_alt", helper_method=ctx._discover_or_create_flavor, flv_ram=config.CONF.tempest.flavor_ref_alt_ram), mock.call("compute", "fixed_network_name", helper_method=ctx._create_network_resources), mock.call("orchestration", "instance_type", helper_method=ctx._discover_or_create_flavor, flv_ram=config.CONF.tempest.heat_instance_type_ram)], mock__configure_option.call_args_list)
def mocked_download(self, size): if not hasattr(PhotoAsset, "already_downloaded"): response = orig_download(self, size) setattr(PhotoAsset, "already_downloaded", True) return response return mock.MagicMock()
self.assertEqual(0, self.rqcore.cores.locked_cores) def test_unlockAllWhenNimbyLocked(self): self.machineMock.return_value.state = rqd.compiled_proto.host_pb2.UP self.nimbyMock.return_value.locked = True self.rqcore.cores.total_cores = 50 self.rqcore.cores.idle_cores = 40 self.rqcore.cores.locked_cores = 10 self.rqcore.unlockAll() self.assertEqual(40, self.rqcore.cores.idle_cores) self.assertEqual(0, self.rqcore.cores.locked_cores) @mock.patch('rqd.rqutil.checkAndCreateUser', new=mock.MagicMock()) @mock.patch('rqd.rqutil.permissionsHigh', new=mock.MagicMock()) @mock.patch('rqd.rqutil.permissionsLow', new=mock.MagicMock()) @mock.patch('subprocess.Popen') @mock.patch('time.time') @mock.patch('rqd.rqutil.permissionsUser', spec=True) class FrameAttendantThreadTests(pyfakefs.fake_filesystem_unittest.TestCase): def setUp(self): self.setUpPyfakefs() rqd.rqconstants.SU_ARGUEMENT = '-c' @mock.patch('platform.system', new=mock.Mock(return_value='Linux')) @mock.patch('tempfile.gettempdir') def test_runLinux(self, getTempDirMock, permsUser, timeMock, popenMock): # mkdirMock, openMock, # given currentTime = 1568070634.3
def setup(self, mock_machine, mock_exists): mock_machine.return_value = 'x86_64' def side_effect(filename): if filename.endswith('.config/kiwi/config.yml'): return False elif filename.endswith('etc/kiwi.yml'): return False else: return True mock_exists.side_effect = side_effect description = XMLDescription( '../data/example_disk_config.xml' ) self.context_manager_mock = mock.Mock() self.file_mock = mock.Mock() self.enter_mock = mock.Mock() self.exit_mock = mock.Mock() self.enter_mock.return_value = self.file_mock setattr(self.context_manager_mock, '__enter__', self.enter_mock) setattr(self.context_manager_mock, '__exit__', self.exit_mock) self.device_map = { 'root': MappedDevice('/dev/root-device', mock.Mock()), 'readonly': MappedDevice('/dev/readonly-root-device', mock.Mock()), 'boot': MappedDevice('/dev/boot-device', mock.Mock()), 'prep': MappedDevice('/dev/prep-device', mock.Mock()), 'efi': MappedDevice('/dev/efi-device', mock.Mock()), 'spare': MappedDevice('/dev/spare-device', mock.Mock()) } self.id_map = { 'kiwi_RootPart': 1, 'kiwi_BootPart': 1 } self.id_map_sorted = OrderedDict( sorted(self.id_map.items()) ) self.boot_names_type = namedtuple( 'boot_names_type', ['kernel_name', 'initrd_name'] ) self.block_operation = mock.Mock() self.block_operation.get_blkid = mock.Mock( return_value='blkid_result' ) self.block_operation.get_filesystem = mock.Mock( return_value='blkid_result_fs' ) kiwi.builder.disk.BlockID = mock.Mock( return_value=self.block_operation ) self.loop_provider = mock.Mock() kiwi.builder.disk.LoopDevice = mock.Mock( return_value=self.loop_provider ) self.disk = mock.Mock() provider = mock.Mock() provider.get_device = mock.Mock( return_value='/dev/some-loop' ) self.disk.storage_provider = provider self.partitioner = mock.Mock() self.partitioner.get_id = mock.Mock( return_value=1 ) self.disk.partitioner = self.partitioner self.disk.get_uuid = mock.Mock( return_value='0815' ) self.disk.get_public_partition_id_map = mock.Mock( return_value=self.id_map_sorted ) self.disk.get_device = mock.Mock( return_value=self.device_map ) kernel_info = mock.Mock() kernel_info.version = '1.2.3' kernel_info.name = 'vmlinuz-1.2.3-default' self.kernel = mock.Mock() self.kernel.get_kernel = mock.Mock( return_value=kernel_info ) self.kernel.get_xen_hypervisor = mock.Mock() self.kernel.copy_kernel = mock.Mock() self.kernel.copy_xen_hypervisor = mock.Mock() kiwi.builder.disk.Kernel = mock.Mock( return_value=self.kernel ) self.disk.subformat = mock.Mock() self.disk.subformat.get_target_file_path_for_format = mock.Mock( return_value='some-target-format-name' ) kiwi.builder.disk.DiskFormat = mock.Mock( return_value=self.disk.subformat ) kiwi.builder.disk.Disk = mock.Mock( return_value=self.disk ) self.disk_setup = mock.Mock() self.disk_setup.get_disksize_mbytes.return_value = 1024 self.disk_setup.boot_partition_size.return_value = 0 self.disk_setup.get_efi_label = mock.Mock( return_value='EFI' ) self.disk_setup.get_root_label = mock.Mock( return_value='ROOT' ) self.disk_setup.get_boot_label = mock.Mock( return_value='BOOT' ) self.disk_setup.need_boot_partition = mock.Mock( return_value=True ) self.bootloader_install = mock.Mock() kiwi.builder.disk.BootLoaderInstall = mock.MagicMock( return_value=self.bootloader_install ) self.bootloader_config = mock.Mock() self.bootloader_config.get_boot_cmdline = mock.Mock( return_value='boot_cmdline' ) kiwi.builder.disk.BootLoaderConfig = mock.MagicMock( return_value=self.bootloader_config ) kiwi.builder.disk.DiskSetup = mock.MagicMock( return_value=self.disk_setup ) self.boot_image_task = mock.Mock() self.boot_image_task.boot_root_directory = 'boot_dir' self.boot_image_task.kernel_filename = 'kernel' self.boot_image_task.initrd_filename = 'initrd' self.boot_image_task.xen_hypervisor_filename = 'xen_hypervisor' self.boot_image_task.get_boot_names.return_value = self.boot_names_type( kernel_name='linux.vmx', initrd_name='initrd.vmx' ) kiwi.builder.disk.BootImage = mock.Mock( return_value=self.boot_image_task ) self.firmware = mock.Mock() self.firmware.get_legacy_bios_partition_size.return_value = 0 self.firmware.get_efi_partition_size.return_value = 0 self.firmware.get_prep_partition_size.return_value = 0 self.firmware.efi_mode = mock.Mock( return_value='efi' ) kiwi.builder.disk.FirmWare = mock.Mock( return_value=self.firmware ) self.setup = mock.Mock() kiwi.builder.disk.SystemSetup = mock.Mock( return_value=self.setup ) self.install_image = mock.Mock() kiwi.builder.disk.InstallImageBuilder = mock.Mock( return_value=self.install_image ) self.raid_root = mock.Mock() self.raid_root.get_device.return_value = MappedDevice( '/dev/md0', mock.Mock() ) kiwi.builder.disk.RaidDevice = mock.Mock( return_value=self.raid_root ) self.luks_root = mock.Mock() kiwi.builder.disk.LuksDevice = mock.Mock( return_value=self.luks_root ) self.disk_builder = DiskBuilder( XMLState(description.load()), 'target_dir', 'root_dir', custom_args={'signing_keys': ['key_file_a', 'key_file_b']} ) self.disk_builder.root_filesystem_is_overlay = False self.disk_builder.build_type_name = 'oem' self.disk_builder.image_format = None
def test_getFrame(self): frame_id = 'arbitrary-frame-id' frame = mock.MagicMock(spec=rqd.rqnetwork.RunningFrame) self.rqcore.storeFrame(frame_id, frame) self.assertEqual(frame, self.rqcore.getFrame(frame_id))
def test_port_get_live_state(self): t = template_format.parse(neutron_port_template) t['resources']['port']['properties']['value_specs'] = { 'binding:vif_type': 'test' } stack = utils.parse_stack(t) port = stack['port'] resp = { 'port': { 'status': 'DOWN', 'binding:host_id': '', 'name': 'flip-port-xjbal77qope3', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': 'd6859535-efef-4184-b236-e5fcae856e0f', 'dns_name': '', 'extra_dhcp_opts': [], 'mac_address': 'fa:16:3e:fe:64:79', 'qos_policy_id': 'some', 'dns_assignment': [], 'binding:vif_details': {}, 'binding:vif_type': 'unbound', 'device_owner': '', 'tenant_id': '30f466e3d14b4251853899f9c26e2b66', 'binding:profile': {}, 'port_security_enabled': True, 'binding:vnic_type': 'normal', 'fixed_ips': [{ 'subnet_id': '02d9608f-8f30-4611-ad02-69855c82457f', 'ip_address': '10.0.3.4' }], 'id': '829bf5c1-b59c-40ad-80e3-ea15a93879f3', 'security_groups': ['c276247f-50fd-4289-862a-80fb81a55de1'], 'device_id': '' } } port.client().show_port = mock.MagicMock(return_value=resp) port.resource_id = '1234' port._data = {} port.data_set = mock.Mock() reality = port.get_live_state(port.properties) expected = { 'allowed_address_pairs': [], 'admin_state_up': True, 'device_owner': '', 'port_security_enabled': True, 'binding:vnic_type': 'normal', 'fixed_ips': [{ 'subnet': '02d9608f-8f30-4611-ad02-69855c82457f', 'ip_address': '10.0.3.4' }], 'security_groups': ['c276247f-50fd-4289-862a-80fb81a55de1'], 'device_id': '', 'dns_name': '', 'qos_policy': 'some', 'value_specs': { 'binding:vif_type': 'unbound' } } self.assertEqual(set(expected.keys()), set(reality.keys())) for key in expected: self.assertEqual(expected[key], reality[key])
def test_getFrameKeys(self): frame_ids = ['frame1', 'frame2'] self.rqcore.storeFrame(frame_ids[0], mock.MagicMock(spec=rqd.rqnetwork.RunningFrame)) self.rqcore.storeFrame(frame_ids[1], mock.MagicMock(spec=rqd.rqnetwork.RunningFrame)) self.assertEqual(set(frame_ids), set(self.rqcore.getFrameKeys()))
def test_wrap(self, version, expected_class): client = mock.MagicMock() client.choose_version.return_value = version self.assertIsInstance(cinder_wrapper.wrap(client, mock.Mock()), expected_class)
def get_event_code(self): form = SuspendCaseForm(case=mock.MagicMock()) return form.fields["event_code"].choices[0][0]