def test_getHostGuestMapping_incomplete_data(self, mock_client):
expected_hostname = None
expected_hypervisorId = 'Fake_uuid'
expected_guestId = 'guest1UUID'
expected_guest_state = Guest.STATE_UNKNOWN
fake_parent = MagicMock()
fake_parent.value = 'Fake_parent'
fake_vm_id = MagicMock()
fake_vm_id.value = 'guest1'
fake_vm = MagicMock()
fake_vm.ManagedObjectReference = [fake_vm_id]
fake_vms = {'guest1': {'runtime.powerState': 'BOGUS_STATE',
'config.uuid': expected_guestId}}
self.esx.vms = fake_vms
fake_host = {'hardware.systemInfo.uuid': expected_hypervisorId,
'parent': fake_parent,
'vm': fake_vm
}
fake_hosts = {'random-host-id': fake_host}
self.esx.hosts = fake_hosts
expected_result = Hypervisor(hypervisorId=expected_hypervisorId,
name=expected_hostname,
guestIds=[Guest(expected_guestId,
self.esx,
expected_guest_state,
hypervisorType='vmware')
]
)
result = self.esx.getHostGuestMapping()['hypervisors'][0]
self.assertEqual(expected_result.toDict(), result.toDict())
def test_getHostGuestMapping(self, mock_client):
expected_hostname = 'Fake_hostname'
expected_hypervisorId = 'Fake_uuid'
expected_guestId = 'guest1UUID'
expected_guest_state = Guest.STATE_RUNNING
fake_parent = MagicMock()
fake_parent.value = 'Fake_parent'
fake_vm_id = MagicMock()
fake_vm_id.value = 'guest1'
fake_vm = MagicMock()
fake_vm.ManagedObjectReference = [fake_vm_id]
fake_vms = {'guest1': {'runtime.powerState': 'poweredOn',
'config.uuid': expected_guestId}}
self.esx.vms = fake_vms
fake_host = {'hardware.systemInfo.uuid': expected_hypervisorId,
'name': expected_hostname,
'parent': fake_parent,
'vm': fake_vm
}
fake_hosts = {'random-host-id': fake_host}
self.esx.hosts = fake_hosts
expected_result = Hypervisor(hypervisorId=expected_hypervisorId,
name=expected_hostname,
guestIds=[Guest(expected_guestId,
self.esx,
expected_guest_state)
]
)
result = self.esx.getHostGuestMapping()['hypervisors'][0]
self.assertTrue(expected_result.toDict() == result.toDict())
def test_publish_no_points(mock_influxdb):
mocked = "test"
host = "host"
port = 1234
database = "db"
timeout = 3
mocked = mock_influxdb.return_value
mocked.write_points = MagicMock()
timestamp_format = "%Y-%m-%dT%H:%M:%SZ"
metrics = MagicMock()
dimensionOne = MagicMock()
dimensionOne.name = "dimensionOneName"
dimensionOne.value = "dimensionOneValue"
dimensionTwo = MagicMock()
dimensionTwo.name = "dimensionTwoName"
dimensionTwo.value = "dimensionTwoValue"
metrics.dimensions = [dimensionOne, dimensionTwo]
metrics.counters = []
metrics.timers = []
publisher = kadabra.publishers.InfluxDBPublisher(host, port, database,
timeout)
publisher.publish([metrics])
publisher.client.write_points.assert_has_calls([])
def test_getHostGuestMappingNoHostName(self, mock_client):
expected_hypervisorId = 'Fake_uuid'
expected_guestId = 'guest1UUID'
expected_guest_state = Guest.STATE_RUNNING
fake_parent = MagicMock()
fake_parent.value = 'fake_parent_id'
fake_parent._type = 'ClusterComputeResource'
fake_vm_id = MagicMock()
fake_vm_id.value = 'guest1'
fake_vm = MagicMock()
fake_vm.ManagedObjectReference = [fake_vm_id]
fake_vms = {'guest1': {'runtime.powerState': 'poweredOn',
'config.uuid': expected_guestId}}
self.esx.vms = fake_vms
fake_host = {'hardware.systemInfo.uuid': expected_hypervisorId,
'config.network.dnsConfig.domainName': 'domainname',
'config.product.version': '1.2.3',
'hardware.cpuInfo.numCpuPackages': '1',
'parent': fake_parent,
'vm': fake_vm,
}
fake_hosts = {'random-host-id': fake_host}
self.esx.hosts = fake_hosts
fake_cluster = {'name': 'Fake_cluster_name'}
self.esx.clusters = {'fake_parent_id': fake_cluster}
assert (len(self.esx.getHostGuestMapping()['hypervisors']) == 0)
def test_api_post_rollouts(tmpdir, clicreator):
profile = {}
action_meanings = {0: 'RIGHT', 1: 'LEFT'}
raw_image_input = False
job_queue = JobQueue()
is_job_running, is_rollout_on_memory = MagicMock(), MagicMock()
client = clicreator(
profile, tmpdir, action_meanings, raw_image_input, job_queue, is_job_running,
is_rollout_on_memory)
is_job_running.value = True
resp = client.post('/api/rollouts', data=None, content_type='application/json')
data = assert_resp_and_get_json_data(resp)
assert data
assert len(data) == 2
assert not data['rollout_path']
assert not data['is_rollout_started']
is_job_running.value = False
req = {'step_count': 99}
resp = client.post('/api/rollouts', data=json.dumps(req), content_type='application/json')
data = assert_resp_and_get_json_data(resp)
assert data
assert len(data) == 2
assert os.path.exists(data['rollout_path'])
assert os.path.exists(os.path.join(data['rollout_path'], 'images'))
assert data['is_rollout_started']
# if dispatch_rollout_job process could be complicated, should be separated
assert job_queue.value
assert job_queue.value['type'] == 'ROLLOUT'
assert job_queue.value['data']
assert job_queue.value['data']['rollout_dir'] == data['rollout_path']
assert job_queue.value['data']['rollout_id'] == os.path.basename(data['rollout_path'])
assert job_queue.value['data']['step_count'] == 99
def test_getHostGuestMapping(self, mock_client):
expected_hostname = 'hostname.domainname'
expected_hypervisorId = 'Fake_uuid'
expected_guestId = 'guest1UUID'
expected_guest_state = Guest.STATE_RUNNING
fake_parent = MagicMock()
fake_parent.value = 'fake_parent_id'
fake_parent._type = 'ClusterComputeResource'
fake_vm_id = MagicMock()
fake_vm_id.value = 'guest1'
fake_vm = MagicMock()
fake_vm.ManagedObjectReference = [fake_vm_id]
fake_vms = {
'guest1': {
'runtime.powerState': 'poweredOn',
'config.uuid': expected_guestId
}
}
self.esx.vms = fake_vms
fake_host = {
'hardware.systemInfo.uuid': expected_hypervisorId,
'config.network.dnsConfig.hostName': 'hostname',
'config.network.dnsConfig.domainName': 'domainname',
'config.product.version': '1.2.3',
'hardware.cpuInfo.numCpuPackages': '1',
'name': expected_hostname,
'parent': fake_parent,
'vm': fake_vm,
}
fake_hosts = {'random-host-id': fake_host}
self.esx.hosts = fake_hosts
fake_cluster = {'name': 'Fake_cluster_name'}
self.esx.clusters = {'fake_parent_id': fake_cluster}
expected_result = Hypervisor(hypervisorId=expected_hypervisorId,
name=expected_hostname,
guestIds=[
Guest(
expected_guestId,
self.esx.CONFIG_TYPE,
expected_guest_state,
)
],
facts={
Hypervisor.CPU_SOCKET_FACT:
'1',
Hypervisor.HYPERVISOR_TYPE_FACT:
'vmware',
Hypervisor.HYPERVISOR_VERSION_FACT:
'1.2.3',
Hypervisor.HYPERVISOR_CLUSTER:
'Fake_cluster_name',
})
result = self.esx.getHostGuestMapping()['hypervisors'][0]
self.assertEqual(expected_result.toDict(), result.toDict())
def test_api_get_rollouts_saliency(tmpdir, clicreator):
profile = {}
action_meanings = {0: 'RIGHT', 1: 'LEFT'}
raw_image_input = False
job_queue = JobQueue()
is_job_running, is_rollout_on_memory = MagicMock(), MagicMock()
client = clicreator(profile, tmpdir, action_meanings, raw_image_input,
job_queue, is_job_running, is_rollout_on_memory)
rollout_id = datetime.datetime.strftime(datetime.datetime.now(),
timestamp_format)
saliency_url = '/api/rollouts/{}/saliency'.format(rollout_id)
is_job_running.value = True
is_rollout_on_memory.value = True
resp = client.post(saliency_url,
data=None,
content_type='application/json')
data = assert_resp_and_get_json_data(resp)
assert data
assert len(data) == 1
assert not data['is_saliency_started']
is_job_running.value = False
is_rollout_on_memory.value = False
resp = client.post(saliency_url,
data=None,
content_type='application/json')
data = assert_resp_and_get_json_data(resp)
assert data
assert len(data) == 1
assert not data['is_saliency_started']
is_job_running.value = False
is_rollout_on_memory.value = True
req = {'from_step': 10, 'to_step': 99, 'actor_intensity': 1}
resp = client.post(saliency_url,
data=json.dumps(req),
content_type='application/json')
data = assert_resp_and_get_json_data(resp)
assert data
assert len(data) == 1
assert data['is_saliency_started']
# if dispatch_saliency_job process could be complicated, should be separated
assert job_queue.value
assert job_queue.value['type'] == 'SALIENCY'
assert job_queue.value['data']
assert job_queue.value['data']['rollout_id'] == rollout_id
assert job_queue.value['data']['rollout_dir'] == os.path.join(
tmpdir, 'rollouts', rollout_id)
assert job_queue.value['data']['from_step'] == 10
assert job_queue.value['data']['to_step'] == 99
assert job_queue.value['data']['intensity']
assert job_queue.value['data']['intensity']['actor_intensity'] == 1
def test_getHostGuestMapping(self, mock_client):
expected_hostname = 'hostname.domainname'
expected_hypervisorId = 'Fake_uuid'
expected_guestId = 'guest1UUID'
expected_guest_state = Guest.STATE_RUNNING
fake_parent = MagicMock()
fake_parent.value = 'fake_parent_id'
fake_parent._type = 'ClusterComputeResource'
fake_vm_id = MagicMock()
fake_vm_id.value = 'guest1'
fake_vm = MagicMock()
fake_vm.ManagedObjectReference = [fake_vm_id]
fake_vms = {'guest1': {'runtime.powerState': 'poweredOn',
'config.uuid': expected_guestId}}
self.esx.vms = fake_vms
fake_host = {'hardware.systemInfo.uuid': expected_hypervisorId,
'config.network.dnsConfig.hostName': 'hostname',
'config.network.dnsConfig.domainName': 'domainname',
'config.product.version': '1.2.3',
'hardware.cpuInfo.numCpuPackages': '1',
'name': expected_hostname,
'parent': fake_parent,
'vm': fake_vm,
}
fake_hosts = {'random-host-id': fake_host}
self.esx.hosts = fake_hosts
fake_cluster = {'name': 'Fake_cluster_name'}
self.esx.clusters = {'fake_parent_id': fake_cluster}
expected_result = Hypervisor(
hypervisorId=expected_hypervisorId,
name=expected_hostname,
guestIds=[
Guest(
expected_guestId,
self.esx.CONFIG_TYPE,
expected_guest_state,
)
],
facts={
Hypervisor.CPU_SOCKET_FACT: '1',
Hypervisor.HYPERVISOR_TYPE_FACT: 'vmware',
Hypervisor.HYPERVISOR_VERSION_FACT: '1.2.3',
Hypervisor.HYPERVISOR_CLUSTER: 'Fake_cluster_name',
Hypervisor.SYSTEM_UUID_FACT: expected_hypervisorId
}
)
result = self.esx.getHostGuestMapping()['hypervisors'][0]
self.assertEqual(expected_result.toDict(), result.toDict())
def test_getHostGuestMapping_incomplete_data(self, mock_client):
expected_hostname = 'hostname.domainname'
expected_hypervisorId = 'Fake_uuid'
expected_guestId = 'guest1UUID'
expected_guest_state = Guest.STATE_UNKNOWN
fake_parent = MagicMock()
fake_parent.value = 'Fake_parent'
fake_vm_id = MagicMock()
fake_vm_id.value = 'guest1'
fake_vm = MagicMock()
fake_vm.ManagedObjectReference = [fake_vm_id]
fake_vms = {
'guest1': {
'runtime.powerState': 'BOGUS_STATE',
'config.uuid': expected_guestId
}
}
self.esx.vms = fake_vms
fake_host = {
'hardware.systemInfo.uuid': expected_hypervisorId,
'config.network.dnsConfig.hostName': 'hostname',
'config.network.dnsConfig.domainName': 'domainname',
'config.product.version': '1.2.3',
'hardware.cpuInfo.numCpuPackages': '1',
'parent': fake_parent,
'vm': fake_vm
}
fake_hosts = {'random-host-id': fake_host}
self.esx.hosts = fake_hosts
expected_result = Hypervisor(hypervisorId=expected_hypervisorId,
name=expected_hostname,
guestIds=[
Guest(
expected_guestId,
self.esx,
expected_guest_state,
)
],
facts={
Hypervisor.CPU_SOCKET_FACT:
'1',
Hypervisor.HYPERVISOR_TYPE_FACT:
'vmware',
Hypervisor.HYPERVISOR_VERSION_FACT:
'1.2.3',
})
result = self.esx.getHostGuestMapping()['hypervisors'][0]
self.assertEqual(expected_result.toDict(), result.toDict())
def test_walk_BooleanNode(self):
nw = GraphDSLNodeWalker(self.graphmgr)
node = MagicMock()
node.value = 'TRUE'
nw.walk_BooleanNode(node, [])
self.assertTrue(node.value)
node = MagicMock()
node.value = 'FALSE'
nw.walk_BooleanNode(node, [])
self.assertFalse(node.value)
def test_post_new_attachment(self, mock_fields):
request = DummyRequest(['/attachment'])
request.method = 'POST'
request.content = 'mocked'
attachment_id = 'B5B4ED80AC3B894523D72E375DACAA2FC6606C18EDF680FE95903086C8B5E14A'
_file = MagicMock()
_file.value = 'some mocked value'
_file.type = 'some mocked type'
_file.filename = 'filename.txt'
mock_fields.return_value = {'attachment': _file}
when(self.mail_service).save_attachment(
'some mocked value',
'some mocked type').thenReturn(defer.succeed(attachment_id))
d = self.web.get(request)
def assert_response(_):
self.assertEqual(201, request.code)
self.assertEqual('/attachment/%s' % attachment_id,
request.headers['Location'])
response_json = {
'ident': attachment_id,
'content-type': 'some mocked type',
'name': 'filename.txt',
'size': 17,
'encoding': 'base64'
}
self.assertEqual(response_json, json.loads(request.written[0]))
verify(self.mail_service).save_attachment('some mocked value',
'some mocked type')
d.addCallback(assert_response)
return d
def test_post_attachment_fails(self, mock_fields):
request = DummyRequest(['/attachment'])
request.method = 'POST'
request.content = 'mocked'
_file = MagicMock()
_file.value = 'some mocked value'
_file.type = 'some mocked type'
mock_fields.return_value = {'attachment': _file}
when(self.mail_service).save_attachment('some mocked value',
'some mocked type').thenReturn(
defer.fail(Exception))
d = self.web.get(request)
def assert_response(_):
self.assertEqual(500, request.code)
self.assertFalse(
request.responseHeaders.hasHeader('Location'.lower()))
self.assertIn("message", json.loads(request.written[0]))
verify(self.mail_service).save_attachment('some mocked value',
'some mocked type')
d.addCallback(assert_response)
return d
def test_use(self):
ammo = Ammo(manager)
target = Mock()
target.value = 10
target.name = "mock"
ammo.use(target)
assert_equal(0, ammo.amt)
def _test_wlvllogg_import_from_diveroffice_files(
self, filenames, mock_filenames, mock_skippopup,
mock_encoding, mock_iface, mock_askuser,
mock_notfoundquestion, mock_messagebarandlog):
mocks_notfoundquestion = []
for answer, value in [['ok', 'rb1'], ['ok', 'rb2'],
['skip', 'rb3']]:
a_mock = MagicMock()
a_mock.answer = answer
a_mock.value = value
a_mock.reuse_column = 'location'
mocks_notfoundquestion.append(a_mock)
mock_notfoundquestion.side_effect = mocks_notfoundquestion
mock_filenames.return_value = filenames
mock_encoding.return_value = ['utf-8']
ms = MagicMock()
ms.settingsdict = OrderedDict()
importer = DiverofficeImport(self.iface.mainWindow(),
ms)
importer.select_files_and_load_gui()
importer.start_import(importer.files,
importer.skip_rows.checked,
importer.confirm_names.checked,
importer.import_all_data.checked)
print('\n'.join([
str(x) for x in mock_messagebarandlog.mock_calls
]))
def a_parameter():
p = MagicMock()
p.id = a_uuid_string()
p.name = a_string()
p.parameterType = 'double'
p.value = str(uniform(-100, 100))
return p
def _test_wlvllogg_import_from_diveroffice_files(self, filenames, mock_filenames, mock_skippopup, mock_encoding, mock_iface, mock_askuser, mock_notfoundquestion, mock_messagebarandlog):
mocks_notfoundquestion = []
for answer, value in [['ok', 'rb1'],
['ok', 'rb2'],
['skip', 'rb3']]:
a_mock = MagicMock()
a_mock.answer = answer
a_mock.value = value
a_mock.reuse_column = 'location'
mocks_notfoundquestion.append(a_mock)
mock_notfoundquestion.side_effect = mocks_notfoundquestion
mock_filenames.return_value = filenames
mock_encoding.return_value = ['utf-8']
ms = MagicMock()
ms.settingsdict = OrderedDict()
importer = DiverofficeImport(self.iface.mainWindow(), ms)
importer.select_files_and_load_gui()
importer.start_import(importer.files, importer.skip_rows.checked, importer.confirm_names.checked, importer.import_all_data.checked)
print('\n'.join([str(x) for x in mock_messagebarandlog.mock_calls]))
def test_getHostGuestMapping_incomplete_data(self, mock_client):
expected_hostname = 'hostname.domainname'
expected_hypervisorId = 'Fake_uuid'
expected_guestId = 'guest1UUID'
expected_guest_state = Guest.STATE_UNKNOWN
fake_parent = MagicMock()
fake_parent.value = 'Fake_parent'
fake_vm_id = MagicMock()
fake_vm_id.value = 'guest1'
fake_vm = MagicMock()
fake_vm.ManagedObjectReference = [fake_vm_id]
fake_vms = {'guest1': {'runtime.powerState': 'BOGUS_STATE',
'config.uuid': expected_guestId}}
self.esx.vms = fake_vms
fake_host = {'hardware.systemInfo.uuid': expected_hypervisorId,
'config.network.dnsConfig.hostName': 'hostname',
'config.network.dnsConfig.domainName': 'domainname',
'config.product.version': '1.2.3',
'hardware.cpuInfo.numCpuPackages': '1',
'parent': fake_parent,
'vm': fake_vm
}
fake_hosts = {'random-host-id': fake_host}
self.esx.hosts = fake_hosts
expected_result = Hypervisor(
hypervisorId=expected_hypervisorId,
name=expected_hostname,
guestIds=[
Guest(
expected_guestId,
self.esx,
expected_guest_state,
)
],
facts={
Hypervisor.CPU_SOCKET_FACT: '1',
Hypervisor.HYPERVISOR_TYPE_FACT: 'vmware',
Hypervisor.HYPERVISOR_VERSION_FACT: '1.2.3',
}
)
result = self.esx.getHostGuestMapping()['hypervisors'][0]
self.assertEqual(expected_result.toDict(), result.toDict())
def test_update_host_cache_in_thread(self, disconnect_mock, connect_mock,
spec_mock, update_mock,
update_host_mock, query_spec_mock,
perf_manager_mock,
prop_collector_mock):
# Test Values.
counter = MagicMock()
counter.groupInfo.key = "mem"
counter.nameInfo.key = "consumed"
counter.key = 65613
n = 5
statValues = ','.join([str(x) for x in range(1, n + 1)])
statAverage = sum(range(1, n + 1)) / len(range(1, n + 1))
stat = MagicMock()
stat.value = [MagicMock()]
stat.value[0].id.counterId = 65613
stat.value[0].value = statValues
# Mock the Vim APIs.
pc_return_mock = MagicMock({'WaitForUpdatesEx.return_value': {}})
summarize_stats = {'QueryPerf.return_value': [stat]}
pm_return_mock = MagicMock(perfCounter=[counter], **summarize_stats)
# Tie the mocked APIs with VimClient.
prop_collector_mock.return_value = pc_return_mock
perf_manager_mock.return_value = pm_return_mock
# Create VimClient.
vim_client = VimClient("esx.local",
"root",
"password",
min_interval=0.1,
auto_sync=True,
stats_interval=0.2)
# Verify that the update mock is called a few times.
retry = 0
while update_mock.call_count < 5 and retry < 10:
time.sleep(0.2)
retry += 1
assert_that(retry, is_not(10), "VimClient.update_mock is not "
"called repeatedly")
# Disconnect the client and stop the thread.
vim_client.disconnect(wait=True)
assert_that(disconnect_mock.called, is_(True))
# Verify that update_host_mock is called atleast once and is called
# less number of times than update_mock.
assert_that(update_host_mock.call_count, is_not(0),
"VimClient.update_host_mock is not called repeatedly")
assert_that(update_host_mock.call_count,
less_than(update_mock.call_count))
host_stats = update_host_mock.call_args_list
for host in host_stats:
assert_that(host[0][0]['mem.consumed'], equal_to(statAverage))
def test_getHostGuestMapping(self, mock_client):
expected_hostname = 'hostname.domainname'
expected_hypervisorId = 'Fake_uuid'
expected_guestId = 'guest1UUID'
expected_guest_state = Guest.STATE_RUNNING
fake_parent = MagicMock()
fake_parent.value = 'Fake_parent'
fake_vm_id = MagicMock()
fake_vm_id.value = 'guest1'
fake_vm = MagicMock()
fake_vm.ManagedObjectReference = [fake_vm_id]
fake_vms = {'guest1': {'runtime.powerState': 'poweredOn',
'config.uuid': expected_guestId}}
self.esx.vms = fake_vms
fake_host = {'hardware.systemInfo.uuid': expected_hypervisorId,
'config.network.dnsConfig.hostName': 'hostname',
'config.network.dnsConfig.domainName': 'domainname',
'hardware.cpuInfo.numCpuPackages': '1',
'name': expected_hostname,
'parent': fake_parent,
'vm': fake_vm
}
fake_hosts = {'random-host-id': fake_host}
self.esx.hosts = fake_hosts
expected_result = Hypervisor(
hypervisorId=expected_hypervisorId,
name=expected_hostname,
guestIds=[
Guest(
expected_guestId,
self.esx,
expected_guest_state,
hypervisorType='vmware'
)
],
facts={
'cpu.cpu_socket(s)': '1',
}
)
result = self.esx.getHostGuestMapping()['hypervisors'][0]
self.assertEqual(expected_result.toDict(), result.toDict())
def test_walk_StringNode(self):
nw = GraphDSLNodeWalker(self.graphmgr)
node = MagicMock()
node.value = 'expected'
nw.walk_StringNode(node, [])
self.assertEqual(node.value, 'expected')
def test_walk_NaturalNode(self):
nw = GraphDSLNodeWalker(self.graphmgr)
node = MagicMock()
node.value = '42'
nw.walk_NaturalNode(node, [])
self.assertEqual(node.value, 42)
def test_write_calls_dummy(self):
channel = MagicMock()
listener = MagicMock()
sub = Subscription(channel, listener)
sub.write(32)
channel.write.assert_called_once_with(32)
channel.value = 32
sub.cb_value(channel.value)
listener.cb_value.assert_called_once_with(sub, channel.value)
def test_update_host_cache_in_thread(self, disconnect_mock, connect_mock,
spec_mock, update_mock,
update_host_mock, query_spec_mock,
perf_manager_mock,
prop_collector_mock):
# Test Values.
counter = MagicMock()
counter.groupInfo.key = "mem"
counter.nameInfo.key = "consumed"
counter.key = 65613
n = 5
statValues = ','.join([str(x) for x in range(1, n+1)])
statAverage = sum(range(1, n+1)) / len(range(1, n+1))
stat = MagicMock()
stat.value = [MagicMock()]
stat.value[0].id.counterId = 65613
stat.value[0].value = statValues
# Mock the Vim APIs.
pc_return_mock = MagicMock({'WaitForUpdatesEx.return_value': {}})
summarize_stats = {'QueryPerf.return_value': [stat]}
pm_return_mock = MagicMock(perfCounter=[counter], **summarize_stats)
# Tie the mocked APIs with VimClient.
prop_collector_mock.return_value = pc_return_mock
perf_manager_mock.return_value = pm_return_mock
# Create VimClient.
vim_client = VimClient("esx.local", "root", "password",
min_interval=0.1, auto_sync=True,
stats_interval=0.2)
# Verify that the update mock is called a few times.
retry = 0
while update_mock.call_count < 5 and retry < 10:
time.sleep(0.2)
retry += 1
assert_that(retry, is_not(10), "VimClient.update_mock is not "
"called repeatedly")
# Disconnect the client and stop the thread.
vim_client.disconnect(wait=True)
assert_that(disconnect_mock.called, is_(True))
# Verify that update_host_mock is called atleast once and is called
# less number of times than update_mock.
assert_that(update_host_mock.call_count, is_not(0),
"VimClient.update_host_mock is not called repeatedly")
assert_that(update_host_mock.call_count,
less_than(update_mock.call_count))
host_stats = update_host_mock.call_args_list
for host in host_stats:
assert_that(host[0][0]['mem.consumed'], equal_to(statAverage))
def test_rate_conversion(self):
channel = MagicMock()
listener = MagicMock()
sub = Subscription(channel, listener, 0.01)
channel.value = 32
sub.cb_value(channel.value)
channel.value = 33
sub.cb_value(channel.value)
listener.cb_value.assert_called_once_with(sub, 32)
listener.cb_value.reset_mock()
channel.value = 34
cothread.Sleep(0.01)
sub.cb_value(channel.value)
listener.cb_value.assert_called_once_with(sub, 34)
listener.cb_value.reset_mock()
channel.value = 35
cothread.Sleep(0.01)
sub.cb_value(channel.value)
listener.cb_value.assert_called_once_with(sub, 35)
def test_done(self):
"""
The done callback should be called when the process is ended
"""
proto = SimpleProtocol(lambda x: None)
status = MagicMock()
status.value = MagicMock()
status.value.exitCode = 0
proto.processEnded(status)
self.assertEqual(self.successResultOf(proto.done), status.value)
def test_send_to_client_return(self, _, _2, json_mock):
ws = WebsocketServerComms(self.p, dict(port=1))
response = MagicMock(spec=Return)
response.value = MagicMock()
response.context = MagicMock()
ws._send_to_client(response)
json_mock.dumps.assert_called_once_with(response.value.to_dict())
response.context.finish.assert_called_once_with(
json_mock.dumps.return_value + "\n")
def test_set_command(self):
"""
A smoke test to ensure nothing bizarre happens when we try to set some attribute
"""
args = MagicMock()
args.prop_name = "foo"
args.value = "bar"
with Capture() as captured:
cli.set_command(args, self.syspurposestore)
self.assertTrue('foo set to "bar"' in captured.out)
def test_done_error(self):
"""
The done deferred should errback if the process didn't exit with a
success code.
"""
proto = SimpleProtocol(lambda x: None)
status = MagicMock()
status.value = ProcessTerminated()
proto.processEnded(status)
self.assertFailure(proto.done, ProcessTerminated)
def test_getHostGuestMapping(self, mock_client):
expected_hostname = 'Fake_hostname'
expected_hypervisorId = 'Fake_uuid'
expected_guestId = 'guest1UUID'
expected_guest_state = Guest.STATE_RUNNING
fake_parent = MagicMock()
fake_parent.value = 'Fake_parent'
fake_vm_id = MagicMock()
fake_vm_id.value = 'guest1'
fake_vm = MagicMock()
fake_vm.ManagedObjectReference = [fake_vm_id]
fake_vms = {
'guest1': {
'runtime.powerState': 'poweredOn',
'config.uuid': expected_guestId
}
}
self.esx.vms = fake_vms
fake_host = {
'hardware.systemInfo.uuid': expected_hypervisorId,
'name': expected_hostname,
'parent': fake_parent,
'vm': fake_vm
}
fake_hosts = {'random-host-id': fake_host}
self.esx.hosts = fake_hosts
expected_result = Hypervisor(hypervisorId=expected_hypervisorId,
name=expected_hostname,
guestIds=[
Guest(expected_guestId,
self.esx,
expected_guest_state,
hypervisorType='vmware')
])
result = self.esx.getHostGuestMapping()['hypervisors'][0]
self.assertEqual(expected_result.toDict(), result.toDict())
def test_resolve_node_tag(self):
mock_loader = MagicMock(yaml.Loader)
mock_loader.resolve.return_value = "new_tag"
mock_node = MagicMock(yaml.Node)
mock_node.tag = "old_tag"
mock_node.value = "String"
config_reader = ConfigReader(self.context)
new_node = config_reader.resolve_node_tag(mock_loader, mock_node)
assert new_node.tag == 'new_tag'
def test_excluded_host_tags(vsphere, instance, aggregator):
# Check default value and precedence of instance config over init config
check = VSphereLegacyCheck('vsphere', {}, [instance])
assert check.excluded_host_tags == []
check = VSphereLegacyCheck('vsphere', {"excluded_host_tags": ["vsphere_host"]}, [instance])
assert check.excluded_host_tags == ["vsphere_host"]
instance["excluded_host_tags"] = []
check = VSphereLegacyCheck('vsphere', {"excluded_host_tags": ["vsphere_host"]}, [instance])
assert check.excluded_host_tags == []
# Test host tags are excluded from external host metadata, but still stored in the cache for metrics
vsphere.excluded_host_tags = ["vsphere_host"]
mocked_vm = MockedMOR(spec="VirtualMachine")
mocked_host = MockedMOR(spec="HostSystem")
mocked_mors_attrs = {
mocked_vm: {
"name": "mocked_vm",
"parent": mocked_host,
"runtime.powerState": vim.VirtualMachinePowerState.poweredOn,
},
mocked_host: {"name": "mocked_host", "parent": None},
}
with mock.patch(
"datadog_checks.vsphere.legacy.vsphere_legacy.VSphereLegacyCheck._collect_mors_and_attributes",
return_value=mocked_mors_attrs,
):
server_instance = vsphere._get_server_instance(instance)
result = MagicMock()
result.value = [23.4]
server_instance.content.perfManager.QueryPerf.return_value = [MagicMock(value=[result], entity=mocked_vm)]
vsphere.metadata_cache = MagicMock()
vsphere.metadata_cache.get_metadata.return_value = {"name": "mymetric", "unit": "kb"}
vsphere.in_compatibility_mode = MagicMock()
vsphere.in_compatibility_mode.return_value = False
vsphere.check(instance)
ext_host_tags = vsphere.get_external_host_tags()
# vsphere_host tag not in external metadata
for host, source_tags in ext_host_tags:
if host == u"mocked_vm":
tags = source_tags["vsphere"]
for tag in tags:
assert "vsphere_host:" not in tag
break
# vsphere_host tag still in cache for sending with metrics
aggregator.assert_metric('vsphere.mymetric', value=23.4, hostname="mocked_vm", count=1)
aggregator.assert_metric_has_tag('vsphere.mymetric', tag="vsphere_host:mocked_host", count=1)
def test_change_edges(self):
node1 = StepInst()
node2 = StepInst()
task = TaskInst()
next_step = MagicMock()
node1.nexts.relationship = MagicMock(return_value=next_step)
task.steps.get = MagicMock(side_effect=[node1, node2])
task.change_edges(
[(node1.sid, node2.sid)],
{node1.sid + '->' + node2.sid: {
'label': 'test_value'
}})
next_step.save.assert_called_once()
next_step.value = 'test_value'
def test_getHostGuestMappingNoHostName(self, mock_client):
expected_hypervisorId = 'Fake_uuid'
expected_guestId = 'guest1UUID'
expected_guest_state = Guest.STATE_RUNNING
fake_parent = MagicMock()
fake_parent.value = 'fake_parent_id'
fake_parent._type = 'ClusterComputeResource'
fake_vm_id = MagicMock()
fake_vm_id.value = 'guest1'
fake_vm = MagicMock()
fake_vm.ManagedObjectReference = [fake_vm_id]
fake_vms = {
'guest1': {
'runtime.powerState': 'poweredOn',
'config.uuid': expected_guestId
}
}
self.esx.vms = fake_vms
fake_host = {
'hardware.systemInfo.uuid': expected_hypervisorId,
'config.network.dnsConfig.domainName': 'domainname',
'config.product.version': '1.2.3',
'hardware.cpuInfo.numCpuPackages': '1',
'parent': fake_parent,
'vm': fake_vm,
}
fake_hosts = {'random-host-id': fake_host}
self.esx.hosts = fake_hosts
fake_cluster = {'name': 'Fake_cluster_name'}
self.esx.clusters = {'fake_parent_id': fake_cluster}
assert (len(self.esx.getHostGuestMapping()['hypervisors']) == 0)
def test_result_ascending_order_with_same_value(self):
mock1 = MagicMock()
mock1.value = [20, 'units']
mock1_run_object = MagicMock()
mock1_run_object.getProperty = MagicMock(return_value=mock1)
nxsdata_to_compare_with = MagicMock()
nxsdata_to_compare_with.active_data.nxs.getRun = MagicMock(return_value=mock1_run_object)
mock2 = MagicMock()
mock2.value = [20, 'units']
mock2_run_object = MagicMock()
mock2_run_object.getProperty = MagicMock(return_value=mock2)
nxsdata_to_position = MagicMock()
nxsdata_to_position.active_data.nxs.getRun = MagicMock(return_value=mock2_run_object)
criteria1 = ['arg1', 'descending']
criteria2 = ['arg2', 'descending']
cmp_nxs_data = CompareTwoNXSData(nxsdata_to_compare_with=nxsdata_to_compare_with,
nxsdata_to_position=nxsdata_to_position,
criteria1=criteria1,
criteria2=criteria2)
self.assertEqual(0, cmp_nxs_data.result())
def test_getValue_to_position(self):
''' Assert retrieve value of getRun object for nexusToPosition '''
mock1 = MagicMock()
mock1.value = [10, 'units']
mock_run_object = MagicMock()
mock_run_object.getProperty = MagicMock(return_value=mock1)
nxsdata_to_position = MagicMock()
nxsdata_to_position.active_data.nxs.getRun = MagicMock(return_value=mock_run_object)
cmp_nxs_data = CompareTwoNXSData(nxsdata_to_compare_with=mock1,
nxsdata_to_position=nxsdata_to_position,
criteria1=self.criteria1,
criteria2=self.criteria2)
_param_nexus_to_position = cmp_nxs_data.param_nexus_to_position
self.assertEqual(10, _param_nexus_to_position)
def test__collect_metrics_async_hostname(vsphere, instance, aggregator):
server_instance = vsphere._get_server_instance(instance)
result = MagicMock()
result.value = [23.4]
server_instance.content.perfManager.QueryPerf.return_value = [MagicMock(value=[result])]
mor = {"hostname": "foo"}
vsphere.mor_cache = MagicMock()
vsphere.mor_cache.get_mor.return_value = mor
vsphere.metadata_cache = MagicMock()
vsphere.metadata_cache.get_metadata.return_value = {"name": "mymetric", "unit": "kb"}
vsphere.in_compatibility_mode = MagicMock()
vsphere.in_compatibility_mode.return_value = False
vsphere._collect_metrics_async(instance, [])
aggregator.assert_metric('vsphere.mymetric', value=23.4, hostname="foo")
def test_archive_profile(self):
message = MagicMock()
message.value = fixtures.EVENT_MESSAGE_VALUE
with self.test_flask_app.app_context():
# save the same profile twice on purpose
archiver._archive_profile(message, MagicMock(), MagicMock())
archiver._archive_profile(message, MagicMock(), MagicMock())
hsps = []
with self.test_flask_app.app_context():
hsps = db_interface.get_hsps_by_inventory_id(
"6388350e-b18d-11ea-ad7f-98fa9b07d419", "5432", "10", "0")
# ensure we didnt save the duplicate
self.assertEquals(1, len(hsps))
# cleanup
with self.test_flask_app.app_context():
db_interface.delete_hsps_by_inventory_id(
"6388350e-b18d-11ea-ad7f-98fa9b07d419")
def test_post_attachment_fails(self, mock_fields):
request = DummyRequest(['/attachment'])
request.method = 'POST'
request.content = 'mocked'
_file = MagicMock()
_file.value = 'some mocked value'
_file.type = 'some mocked type'
mock_fields.return_value = {'attachment': _file}
when(self.mail_service).save_attachment('some mocked value', 'some mocked type').thenReturn(defer.fail(Exception))
d = self.web.get(request)
def assert_response(_):
self.assertEqual(500, request.code)
self.assertFalse(request.responseHeaders.hasHeader('Location'.lower()))
self.assertIn("message", json.loads(request.written[0]))
verify(self.mail_service).save_attachment('some mocked value', 'some mocked type')
d.addCallback(assert_response)
return d
def test_host_parent_filter(self):
host = {}
test_parent = MagicMock()
test_parent.value = "theParent"
test_parent._type = "ClusterComputeResource"
host['parent'] = test_parent
# exact match
self.esx.config['filter_host_parents'] = ["theParent"]
self.assertFalse(self.esx.skip_for_parent("test", host))
# wildcard match
self.esx.config['filter_host_parents'] = ["*Parent"]
self.assertFalse(self.esx.skip_for_parent("test", host))
# no match
self.esx.config['filter_host_parents'] = ["notThisOne"]
self.assertTrue(self.esx.skip_for_parent("test", host))
# multi-list match
self.esx.config['filter_host_parents'] = ["*Parent", "notThisOne"]
self.assertFalse(self.esx.skip_for_parent("test", host))
# multi-list no match
self.esx.config['filter_host_parents'] = ["wrongParent", "notThisOne"]
self.assertTrue(self.esx.skip_for_parent("test", host))
self.esx.config['filter_host_parents'] = None
# exact match
self.esx.config['exclude_host_parents'] = ["theParent"]
self.assertTrue(self.esx.skip_for_parent("test", host))
# wildcard match
self.esx.config['exclude_host_parents'] = ["the*"]
self.assertTrue(self.esx.skip_for_parent("test", host))
# no match
self.esx.config['exclude_host_parents'] = ["notThisOne"]
self.assertFalse(self.esx.skip_for_parent("test", host))
# multi-list match
self.esx.config['exclude_host_parents'] = ["the*", "notThisOne"]
self.assertTrue(self.esx.skip_for_parent("test", host))
# multi-list no match
self.esx.config['exclude_host_parents'] = ["wrongParent", "notThisOne"]
self.assertFalse(self.esx.skip_for_parent("test", host))
def test_post_new_attachment(self, mock_fields):
request = DummyRequest(['/attachment'])
request.method = 'POST'
request.content = 'mocked'
attachment_id = 'B5B4ED80AC3B894523D72E375DACAA2FC6606C18EDF680FE95903086C8B5E14A'
_file = MagicMock()
_file.value = 'some mocked value'
_file.type = 'some mocked type'
_file.filename = 'filename.txt'
mock_fields.return_value = {'attachment': _file}
when(self.mail_service).save_attachment('some mocked value', 'some mocked type').thenReturn(defer.succeed(attachment_id))
d = self.web.get(request)
def assert_response(_):
self.assertEqual(201, request.code)
self.assertEqual('/attachment/%s' % attachment_id, request.responseHeaders.getRawHeaders("location")[0])
response_json = {'ident': attachment_id, 'content-type': 'some mocked type',
'name': 'filename.txt', 'size': 17, 'encoding': 'base64'}
self.assertEqual(response_json, json.loads(request.written[0]))
verify(self.mail_service).save_attachment('some mocked value', 'some mocked type')
d.addCallback(assert_response)
return d
def get_mocked_value():
for val in ['foo', 'bar', 'baz']:
m = MagicMock()
m.value = val
yield m
def _get_secret_mock(secret_id):
secret_mock = MagicMock()
secret_mock.value = secret_id + '_value'
return secret_mock
def _get_secret_mock(secret_id):
secret_mock = MagicMock()
secret_mock.value = secret_id + '_value'
return secret_mock
def a_property():
p = MagicMock()
p.key = a_string()
p.value = a_string()
return p
def create_mock_axis(name, init_position, max_velocity):
axis = MagicMock()
axis.name = name
axis.value = init_position
axis.max_velocity = max_velocity
return axis
def test_publish(mock_influxdb):
mocked = "test"
host = "host"
port = 1234
database = "db"
timeout = 3
mocked = mock_influxdb.return_value
mocked.write_points = MagicMock()
timestamp_format = "%Y-%m-%dT%H:%M:%SZ"
metrics = MagicMock()
metrics.timestamp_format = timestamp_format
dimensionOne = MagicMock()
dimensionOne.name = "dimensionOneName"
dimensionOne.value = "dimensionOneValue"
dimensionTwo = MagicMock()
dimensionTwo.name = "dimensionTwoName"
dimensionTwo.value = "dimensionTwoValue"
timerOne = MagicMock()
timerOne.name = "timerOne"
timerOne.value = datetime.timedelta(seconds=10)
timerOne.timestamp = datetime.datetime.utcnow()
timerOne.metadata = {"timerOneMdName": "timerOneMdValue"}
timerOne.unit = MagicMock()
timerOne.unit.name = "timerOneUnit"
timerOne.unit.seconds_offset = 10
timerTwo = MagicMock()
timerTwo.name = "timerTwo"
timerTwo.value = datetime.timedelta(seconds=20)
timerTwo.timestamp = datetime.datetime.utcnow() +\
datetime.timedelta(seconds=5)
timerTwo.metadata = {"timerTwoMdName": "timerTwoMdValue"}
timerTwo.unit = MagicMock()
timerTwo.unit.name = "timerTwoUnit"
timerTwo.unit.seconds_offset = 20
counterOne = MagicMock()
counterOne.name = "counterOne"
counterOne.value = 1.0
counterOne.timestamp = datetime.datetime.utcnow()
counterOne.metadata = {"counterOneMdName": "counterOneMdValue"}
counterTwo = MagicMock()
counterTwo.name = "counterTwo"
counterTwo.value = 2.0
counterTwo.timestamp = datetime.datetime.utcnow() +\
datetime.timedelta(seconds=10)
counterTwo.metadata = {"counterTwoMdName": "counterTwoMdValue"}
metrics.dimensions = [dimensionOne, dimensionTwo]
metrics.counters = [counterOne, counterTwo]
metrics.timers = [timerOne, timerTwo]
tags = {
dimensionOne.name: dimensionOne.value,
dimensionTwo.name: dimensionTwo.value
}
expected_points = [
{
"measurement": timerOne.name,
"tags": tags,
"time": datetime.datetime.strftime(timerOne.timestamp,
timestamp_format),
"fields": merge_dicts(timerOne.metadata, {\
"value": kadabra.utils.timedelta_total_seconds(timerOne.value)\
* timerOne.unit.seconds_offset,
"unit": timerOne.unit.name})
},
{
"measurement": timerTwo.name,
"tags": tags,
"time": datetime.datetime.strftime(timerTwo.timestamp,
timestamp_format),
"fields": merge_dicts(timerTwo.metadata, {\
"value": kadabra.utils.timedelta_total_seconds(timerTwo.value)\
* timerTwo.unit.seconds_offset,
"unit": timerTwo.unit.name})
},
{
"measurement": counterOne.name,
"tags": tags,
"time": datetime.datetime.strftime(counterOne.timestamp,
timestamp_format),
"fields": merge_dicts(counterOne.metadata, {"value":
counterOne.value})
},
{
"measurement": counterTwo.name,
"tags": tags,
"time": datetime.datetime.strftime(counterTwo.timestamp,
timestamp_format),
"fields": merge_dicts(counterTwo.metadata, {"value":
counterTwo.value})
}
]
publisher = kadabra.publishers.InfluxDBPublisher(host, port, database,
timeout)
publisher.publish([metrics])
publisher.client.write_points.assert_called_with(expected_points)
def test_update_relation(self):
stmt = MagicMock()
stmt.__class__.__name__ = 'UpdateStatementNode'
update0 = MagicMock()
update0.__class__.__name__ = 'UpdateSetPropertyNode'
update0.alias = 'elt0'
update0.propname = 'foo'
update0.value = 'bar'
update1 = MagicMock()
update1.__class__.__name__ = 'UpdateAddPropertyNode'
update1.alias = 'elt0'
update1.propname = 'bar'
update1.value = 'biz'
update2 = MagicMock()
update2.__class__.__name__ = 'UpdateUnsetPropertyNode'
update2.alias = 'elt0'
update2.propname = 'baz'
update3 = MagicMock()
update3.__class__.__name__ = 'UpdateDelPropertyNode'
update3.alias = 'elt0'
update3.propname = 'bar'
update3.value = 'baz'
stmt.updates = [update0, update1, update2, update3]
aliased_sets = {
'elt0': {
'type': 'relationships',
'dataset': [
{'_id': 'foo'}
]
}
}
m = Map(value={
'foo_register': 'foo',
'bar_set': {'baz'},
'baz_register': 'foo'
})
self.relationships = {
'foo': m
}
result = self.crud([stmt], aliased_sets)
self.assertEqual(len(result), 1)
self.assertIn('elt0', result[0])
self.assertEqual(len(result[0]['elt0']), 1)
expected = {
'_id': 'foo',
'foo_register': 'bar',
'bar_set': {'biz'}
}
self.assertIn(expected, result[0]['elt0'])
del expected['_id']
self.assertEqual(self.relationships['foo'].current, expected)
