def setUp(self):
api_test.ApiTest.setUp(self)
self.host_0 = datastore_test_util.CreateHost(cluster='free',
hostname='host_0')
self.device_0 = datastore_test_util.CreateDevice(
cluster='free',
hostname=self.host_0.hostname,
device_serial='device_0',
run_target='shamu')
self.device_1 = datastore_test_util.CreateDevice(
cluster='free',
hostname=self.host_0.hostname,
device_serial='device_1',
run_target='shamu')
self.host_1 = datastore_test_util.CreateHost(cluster='free',
hostname='host_1')
self.device_2 = datastore_test_util.CreateDevice(
cluster='free',
hostname=self.host_1.hostname,
device_serial='device_2',
run_target='hammerhead')
self.host_2 = datastore_test_util.CreateHost(cluster='presubmit',
hostname='host_2')
self.device_3 = datastore_test_util.CreateDevice(
cluster='presubmit',
hostname=self.host_2.hostname,
device_serial='device_3',
run_target='hammerhead')
def testGetDevicesToReport(self):
# Test GetDevicesToReport()
datastore_test_util.CreateDevice(
'free', 'atl-1001.mtv', 'null-300', product='shamu',
run_target='shamu', state='Allocated',
device_type=api_messages.DeviceTypeMessage.NULL)
devices = device_info_reporter.GetDevicesToReport()
self.assertEqual(2, len(devices))
for d in devices:
self.assertEqual(d.physical_cluster, d.cluster)
def testDeviceFlatExtraInfo_noneValue(self):
device = datastore_test_util.CreateDevice('acluster',
'ahost',
'adevice',
extra_info={
'product': 'v' * 1000,
'sim_state': None,
})
device = device.key.get()
self.assertEqual(['product:' + 'v' * 80, 'sim_state:'],
device.flated_extra_info)
def _setUpRunTarget(self):
datastore_test_util.CreateHost(cluster='free', hostname='host_0')
datastore_test_util.CreateDevice(cluster='free',
hostname='host_0',
device_serial='device_0',
run_target='shamu')
datastore_test_util.CreateDevice(cluster='free',
hostname='host_0',
device_serial='device_1',
run_target='shamu')
datastore_test_util.CreateHost(cluster='free', hostname='host_1')
datastore_test_util.CreateDevice(cluster='free',
hostname='host_1',
device_serial='device_2',
run_target='hammerhead')
datastore_test_util.CreateHost(cluster='presubmit', hostname='host_2')
datastore_test_util.CreateDevice(cluster='presubmit',
hostname='host_2',
device_serial='device_3',
run_target='hammerhead')
def testDeviceFlatExtraInfo(self):
device = datastore_test_util.CreateDevice('acluster',
'ahost',
'adevice',
extra_info={
'key1': 'value1',
'key2': 'value2',
'product': 'blueline',
'sim_state': 'READY',
})
device = device.key.get()
self.assertEqual(['product:blueline', 'sim_state:READY'],
device.flated_extra_info)
def setUp(self):
testbed_dependent_test.TestbedDependentTest.setUp(self)
env_config.CONFIG.should_send_report = True
self.reporter_webapp = webtest.TestApp(device_info_reporter.APP)
self.ndb_host_1 = datastore_test_util.CreateHost(
'free', 'atl-1001.mtv', timestamp=TIMESTAMP,
extra_info={
'gcertstatus':
('LOAS2 expires in 10h 14m\n'
'corp/normal expires in 10h 47m\n')
})
self.ndb_host_2 = datastore_test_util.CreateHost(
'free', 'atl-1002.mtv', timestamp=TIMESTAMP,
extra_info={
'gcertstatus':
('LOAS2 expires in 1485h 14m\n'
'corp/normal expires in 18h 47m\n')
})
self.ndb_device = datastore_test_util.CreateDevice(
'free', 'atl-1001.mtv', 'a100', product='shamu', run_target='shamu',
state='Allocated', timestamp=TIMESTAMP, last_recovery_time=TIMESTAMP)
self.ndb_device_2 = datastore_test_util.CreateDevice(
'free', 'atl-1001.mtv', 'a200', product='flounder',
run_target='flo', timestamp=TIMESTAMP, last_recovery_time=TIMESTAMP)
def testListRunTargets_hiddenDevice(self):
"""Tests ListRunTargets ignores run targets from hidden devices."""
datastore_test_util.CreateDevice(cluster='free',
hostname=self.host_2.hostname,
device_serial='device_4',
run_target='hammerhead',
hidden=True)
datastore_test_util.CreateDevice(cluster='free',
hostname=self.host_2.hostname,
device_serial='device_5',
run_target='mako',
hidden=True)
api_request = {}
api_response = self.testapp.post_json(
'/_ah/api/RunTargetApi.ListRunTargets', api_request)
run_target_collection = protojson.decode_message(
run_target_api.RunTargetCollection, api_response.body)
self.assertEqual('200 OK', api_response.status)
self.assertEqual(2, len(run_target_collection.run_targets))
# there are other hammerhead devices, so it should still be present
# however, mako shouldn't be there.
expected = [self.SHAMU_RUN_TARGET, self.HAMMERHEAD_RUN_TARGET]
self.AssertRunTargetsListEqual(expected,
run_target_collection.run_targets)
def testListRunTargets_withCluster_noneRunTargets(self):
"""Tests ListRunTargets with 'None' run target for a cluster."""
host_3 = datastore_test_util.CreateHost(cluster='unbundled',
hostname='host_3')
# Device 4 does not have a run target defined
datastore_test_util.CreateDevice(cluster='unbundled',
hostname=host_3.hostname,
device_serial='device_4',
run_target=None)
api_request = {'cluster': host_3.physical_cluster}
api_response = self.testapp.post_json(
'/_ah/api/RunTargetApi.ListRunTargets', api_request)
run_target_collection = protojson.decode_message(
run_target_api.RunTargetCollection, api_response.body)
self.assertEqual('200 OK', api_response.status)
self.assertEqual(0, len(run_target_collection.run_targets))
def testListRunTargets_noneRunTargets(self):
"""Tests ListRunTargets with 'None' run target for all clusters."""
host_3 = datastore_test_util.CreateHost(cluster='unbundled',
hostname='host_3')
# Device 4 does not have a run target defined
datastore_test_util.CreateDevice(cluster='unbundled',
hostname=host_3.hostname,
device_serial='device_4',
run_target=None)
api_request = {}
api_response = self.testapp.post_json(
'/_ah/api/RunTargetApi.ListRunTargets', api_request)
run_target_collection = protojson.decode_message(
run_target_api.RunTargetCollection, api_response.body)
self.assertEqual('200 OK', api_response.status)
self.assertEqual(2, len(run_target_collection.run_targets))
expected = [self.SHAMU_RUN_TARGET, self.HAMMERHEAD_RUN_TARGET]
self.AssertRunTargetsListEqual(expected,
run_target_collection.run_targets)
def testFilterDevices(self):
# Test FilterDevices()
datastore_test_util.CreateDevice(
'foobar',
'atl-1003.mtv',
'a300',
product='walleye',
run_target='walleye',
timestamp=TIMESTAMP)
devices = device_info_reporter.GetDevicesToReport()
free_devices = device_info_reporter.FilterDevices(devices, 'free')
self.assertEqual(2, len(free_devices))
self.assertEqual('free', free_devices[0].physical_cluster)
self.assertEqual('shamu', free_devices[0].product)
self.assertEqual('free', free_devices[1].physical_cluster)
self.assertEqual('flounder', free_devices[1].product)
foo_devices = device_info_reporter.FilterDevices(devices, 'foo')
self.assertEqual(1, len(foo_devices))
self.assertEqual('foobar', foo_devices[0].physical_cluster)
self.assertEqual('walleye', foo_devices[0].product)
def setUp(self):
testbed_dependent_test.TestbedDependentTest.setUp(self)
self.host1 = datastore_test_util.CreateHost('free',
'atl-01.mtv',
lab_name='alab')
self.device_1 = datastore_test_util.CreateDevice('free',
'atl-01.mtv',
'serial_1',
run_target='shamu',
state='Allocated')
self.device_2 = datastore_test_util.CreateDevice('free',
'atl-01.mtv',
'serial_2',
run_target='shamu',
state='Allocated')
self.device_3 = datastore_test_util.CreateDevice('free',
'atl-01.mtv',
'serial_3',
run_target='shamu',
state='Available')
self.device_4 = datastore_test_util.CreateDevice(
'free',
'atl-01.mtv',
'serial_4',
run_target='hammerhead',
state='Available')
self.device_5 = datastore_test_util.CreateDevice(
'free',
'atl-01.mtv',
'serial_5',
run_target='hammerhead',
state='Ignored')
self.host1_devices = [
self.device_1, self.device_2, self.device_3, self.device_4,
self.device_5
]
device_manager._CountDeviceForHost('atl-01.mtv')
datastore_test_util.CreateHost('presubmit',
'atl-02.mtv',
lab_name='alab')
self.device_6 = datastore_test_util.CreateDevice(
'presubmit',
'atl-02.mtv',
'serial_6',
run_target='hammerhead',
state='Allocated')
self.device_7 = datastore_test_util.CreateDevice(
'presubmit',
'atl-02.mtv',
'serial_7',
run_target='hammerhead',
state='Unavailable')
self.device_8 = datastore_test_util.CreateDevice('presubmit',
'atl-02.mtv',
'serial_8',
run_target='bullhead',
state='Gone')
self.device_9 = datastore_test_util.CreateDevice('presubmit',
'atl-02.mtv',
'serial_9',
run_target='angler',
state='Allocated',
hidden=True)
device_manager._CountDeviceForHost('atl-02.mtv')
self.cloud_host = datastore_test_util.CreateHost('dockerized-tf-gke',
'cloud-tf-1234',
lab_name='cloud-tf')
self.device_10 = datastore_test_util.CreateDevice(
'dockerized-tf-gke',
'cloud-tf-1234',
'null-device-0',
run_target='NullDevice')
device_manager._CountDeviceForHost('cloud-tf-1234')
datastore_test_util.CreateHost('', 'mh.host', lab_name='mh')
self.testapp = webtest.TestApp(device_monitor.APP)
# Clear Datastore cache
ndb.get_context().clear_cache()
def setUp(self):
api_test.ApiTest.setUp(self)
self.host_update_state_summary_0 = (
datastore_entities.HostUpdateStateSummary(
total=2,
succeeded=2,
target_version='v1'))
host_count_by_harness_version = {
'version1': 72,
'version2': 20,
}
self.cluster_0 = datastore_test_util.CreateCluster(
cluster='free',
total_devices=10,
offline_devices=1,
available_devices=2,
allocated_devices=7,
device_count_timestamp=self.TIMESTAMP,
host_update_state_summary=self.host_update_state_summary_0,
host_update_state_summaries_by_version=[
self.host_update_state_summary_0],
host_count_by_harness_version=host_count_by_harness_version)
self.cluster_1 = datastore_test_util.CreateCluster(
cluster='paid',
total_devices=2,
offline_devices=0,
available_devices=1,
allocated_devices=1,
device_count_timestamp=self.TIMESTAMP)
datastore_test_util.CreateHost(cluster='free', hostname='host_0')
datastore_test_util.CreateDevice(
cluster='free',
hostname='host_0',
device_serial='device_0',
device_type=api_messages.DeviceTypeMessage.PHYSICAL,
battery_level='100',
run_target='shamu')
datastore_test_util.CreateHost(cluster='free', hostname='host_1')
datastore_test_util.CreateDevice(
cluster='free',
hostname='host_1',
device_serial='device_1',
device_type=api_messages.DeviceTypeMessage.PHYSICAL,
timestamp=self.TIMESTAMP,
run_target='flounder')
datastore_test_util.CreateHost(cluster='paid', hostname='host_2')
datastore_test_util.CreateDevice(
cluster='paid',
hostname='host_2',
device_serial='device_2',
device_type=api_messages.DeviceTypeMessage.PHYSICAL,
run_target='shamu')
# A hidden device
datastore_test_util.CreateDevice(
cluster='paid',
hostname='host_2',
device_serial='device_3',
device_type=api_messages.DeviceTypeMessage.PHYSICAL,
run_target='shamu',
hidden=True)
# A hidden host
datastore_test_util.CreateHost(
cluster='paid', hostname='host_3', hidden=True)
self.note = datastore_entities.Note(user='******',
timestamp=self.TIMESTAMP,
message='Hello, World')
cluster_note = datastore_entities.ClusterNote(cluster='free')
cluster_note.note = self.note
cluster_note.put()
