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]
