def testListPools(self):
"""Tests ListPools."""
datastore_test_util.CreateHost(
cluster='free',
hostname='host_0',
pools=['pool_1'],
timestamp=self.TIMESTAMP,
)
datastore_test_util.CreateHost(
cluster='paid',
hostname='host_1',
pools=['pool_2', 'pool_3'],
timestamp=self.TIMESTAMP,
)
api_request = {'type': 'POOL'}
api_response = self.testapp.post_json(
'/_ah/api/FilterHintApi.ListFilterHints', api_request)
pool_collection = protojson.decode_message(
api_messages.FilterHintCollection, api_response.body)
self.assertEqual('200 OK', api_response.status)
pools = list(pool_collection.filter_hints)
self.assertLen(pool_collection.filter_hints, 3)
self.assertCountEqual(('pool_1', 'pool_2', 'pool_3'),
(pool.value for pool in pools))
def testListHostGroup(self):
"""Tests ListHostGroup."""
datastore_test_util.CreateHost(
cluster='free',
hostname='host_0',
timestamp=self.TIMESTAMP,
)
datastore_test_util.CreateHost(
cluster='paid',
hostname='host_1',
timestamp=self.TIMESTAMP,
)
datastore_test_util.CreateHost(
cluster='free',
hostname='host_2',
hidden=True,
)
api_request = {'type': 'HOST_GROUP'}
api_response = self.testapp.post_json(
'/_ah/api/FilterHintApi.ListFilterHints', api_request)
host_group_collection = protojson.decode_message(
api_messages.FilterHintCollection, api_response.body)
self.assertEqual('200 OK', api_response.status)
self.assertEqual(2, len(host_group_collection.filter_hints))
host_groups = list(host_group_collection.filter_hints)
self.assertEqual(host_groups[0].value, 'free')
self.assertEqual(host_groups[1].value, 'paid')
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 testListTestHarnessVersion(self):
"""Tests ListTestHarnessVersion."""
datastore_test_util.CreateHost(
cluster='free',
hostname='host_0',
timestamp=self.TIMESTAMP,
)
datastore_test_util.CreateHost(
cluster='paid',
hostname='host_1',
timestamp=self.TIMESTAMP,
test_harness='MOBILE_HARNESS',
test_harness_version='3.0.1',
)
datastore_test_util.CreateHost(
cluster='free',
hostname='host_2',
lab_name='alab',
assignee='auser',
hidden=True,
)
api_request = {'type': 'TEST_HARNESS_VERSION'}
api_response = self.testapp.post_json(
'/_ah/api/FilterHintApi.ListFilterHints', api_request)
test_harness_version_collection = protojson.decode_message(
api_messages.FilterHintCollection, api_response.body)
self.assertEqual('200 OK', api_response.status)
self.assertEqual(2, len(test_harness_version_collection.filter_hints))
test_harness_versions = list(
test_harness_version_collection.filter_hints)
self.assertEqual(test_harness_versions[0].value, '1234')
self.assertEqual(test_harness_versions[1].value, '3.0.1')
def testUpdateClusters_calculateHostUpdateStateSummary(self):
cluster_name = 'cluster1'
host1 = datastore_test_util.CreateHost(cluster_name,
'host1.mtv',
lab_name='alab')
host2 = datastore_test_util.CreateHost(cluster_name,
'host2.mtv',
lab_name='alab')
host3 = datastore_test_util.CreateHost(cluster_name,
'host3.mtv',
lab_name='alab')
host4 = datastore_test_util.CreateHost(cluster_name,
'host4.mtv',
lab_name='alab')
host5 = datastore_test_util.CreateHost(cluster_name,
'host5.mtv',
lab_name='alab')
host6 = datastore_test_util.CreateHost(cluster_name,
'host6.mtv',
lab_name='alab')
host7 = datastore_test_util.CreateHost(cluster_name,
'host7.mtv',
lab_name='alab')
host8 = datastore_test_util.CreateHost(cluster_name,
'host8.mtv',
lab_name='alab')
host9 = datastore_test_util.CreateHost(cluster_name,
'host9.mtv',
lab_name='alab')
datastore_test_util.CreateHostUpdateState(
host1.hostname, state=api_messages.HostUpdateState.SYNCING)
datastore_test_util.CreateHostUpdateState(
host2.hostname, state=api_messages.HostUpdateState.SYNCING)
datastore_test_util.CreateHostUpdateState(
host3.hostname, state=api_messages.HostUpdateState.RESTARTING)
datastore_test_util.CreateHostUpdateState(
host4.hostname, state=api_messages.HostUpdateState.ERRORED)
datastore_test_util.CreateHostUpdateState(
host5.hostname, state=api_messages.HostUpdateState.PENDING)
datastore_test_util.CreateHostUpdateState(
host6.hostname, state=api_messages.HostUpdateState.TIMED_OUT)
datastore_test_util.CreateHostUpdateState(
host7.hostname, state=api_messages.HostUpdateState.SUCCEEDED)
datastore_test_util.CreateHostUpdateState(
host8.hostname, state=api_messages.HostUpdateState.SHUTTING_DOWN)
datastore_test_util.CreateHostUpdateState(
host9.hostname, state=api_messages.HostUpdateState.UNKNOWN)
device_monitor._UpdateClusters(
[host1, host2, host3, host4, host5, host6, host7, host8, host9])
cluster = datastore_entities.ClusterInfo.get_by_id(cluster_name)
self.assertEqual(9, cluster.host_update_state_summary.total)
self.assertEqual(1, cluster.host_update_state_summary.pending)
self.assertEqual(2, cluster.host_update_state_summary.syncing)
self.assertEqual(1, cluster.host_update_state_summary.shutting_down)
self.assertEqual(1, cluster.host_update_state_summary.restarting)
self.assertEqual(1, cluster.host_update_state_summary.errored)
self.assertEqual(1, cluster.host_update_state_summary.timed_out)
self.assertEqual(1, cluster.host_update_state_summary.succeeded)
self.assertEqual(1, cluster.host_update_state_summary.unknown)
def testFetchPage_backwardsWithAncestorQuery(self):
self.ndb_host_0 = datastore_test_util.CreateHost(
cluster='free',
hostname='host_0',
timestamp=self.TIMESTAMP,
host_state=api_messages.HostState.RUNNING,
)
self.ndb_host_1 = datastore_test_util.CreateHost(
cluster='paid',
hostname='host_1',
timestamp=self.TIMESTAMP,
device_count_timestamp=self.TIMESTAMP,
)
self._CreateHostInfoHistory(self.ndb_host_1).put()
self.ndb_host_1.host_state = api_messages.HostState.UNKNOWN
self.ndb_host_1.timestamp += datetime.timedelta(hours=1)
self._CreateHostInfoHistory(self.ndb_host_1).put()
self.ndb_host_1.host_state = api_messages.HostState.GONE
self.ndb_host_1.timestamp += datetime.timedelta(hours=1)
self._CreateHostInfoHistory(self.ndb_host_1).put()
self._CreateHostInfoHistory(self.ndb_host_0).put()
self.ndb_host_0.host_state = api_messages.HostState.KILLING
self.ndb_host_0.timestamp += datetime.timedelta(hours=1)
self._CreateHostInfoHistory(self.ndb_host_0).put()
self.ndb_host_0.host_state = api_messages.HostState.GONE
self.ndb_host_0.timestamp += datetime.timedelta(hours=1)
self._CreateHostInfoHistory(self.ndb_host_0).put()
# First page
query = (datastore_entities.HostInfoHistory.query(ancestor=ndb.Key(
datastore_entities.HostInfo, self.ndb_host_0.hostname)).order(
-datastore_entities.HostInfoHistory.timestamp))
histories, prev_cursor, next_cursor = datastore_util.FetchPage(
query, 2)
self.assertEqual(2, len(histories))
self.assertIsNone(prev_cursor)
self.assertIsNotNone(next_cursor)
# Back to first page (ancestor query with backwards)
histories, prev_cursor, next_cursor = datastore_util.FetchPage(
query, 2, backwards=True)
self.assertEqual(2, len(histories))
self.assertEqual(self.ndb_host_0.hostname, histories[0].hostname)
self.assertEqual(api_messages.HostState.GONE, histories[0].host_state)
self.assertEqual(self.ndb_host_0.hostname, histories[1].hostname)
self.assertEqual(api_messages.HostState.KILLING,
histories[1].host_state)
def setUp(self):
api_test.ApiTest.setUp(self)
request_key = ndb.Key(
datastore_entities.Request, REQUEST_ID,
namespace=common.NAMESPACE)
self.request = datastore_test_util.CreateRequest(
request_id=request_key.id(),
user='******',
command_infos=[
datastore_entities.CommandInfo(
command_line='command_line',
cluster='cluster',
run_target='run_target')
])
self.request.put()
self.command = self._AddCommand(
REQUEST_ID,
'1',
command_line='cmd',
cluster='example_cluster',
run_target='hammerhead',
run_count=1,
ants_invocation_id='i123',
ants_work_unit_id='w123')
self.plugin_patcher = mock.patch(
'__main__.env_config.CONFIG.plugin')
self.plugin_patcher.start()
self.host = datastore_test_util.CreateHost('cluster', 'hostname', 'alab')
def testUpdateClusters_noLabNameFound(self):
cluster_name = 'cluster1'
hosts = [
datastore_test_util.CreateHost(cluster_name,
'atl-08.mtv',
lab_name=None),
datastore_test_util.CreateHost(cluster_name,
'atl-09.mtv',
lab_name=None),
datastore_test_util.CreateHost(cluster_name,
'atl-10.mtv',
lab_name=None),
]
device_monitor._UpdateClusters(hosts)
cluster = datastore_entities.ClusterInfo.get_by_id(cluster_name)
self.assertEqual('UNKNOWN', cluster.lab_name)
def testListHostnames(self):
"""Tests ListHosts returns all visible hostnames."""
host_list = [
datastore_test_util.CreateHost(cluster='paid', hostname='host_0'),
datastore_test_util.CreateHost(cluster='free', hostname='host_1')
]
api_request = {'type': 'HOST'}
api_response = self.testapp.post_json(
'/_ah/api/FilterHintApi.ListFilterHints', api_request)
host_collection = protojson.decode_message(
api_messages.FilterHintCollection, api_response.body)
self.assertEqual('200 OK', api_response.status)
self.assertEqual(2, len(host_collection.filter_hints))
hosts = list(host_collection.filter_hints)
self.assertEqual(hosts[0].value, host_list[0].hostname)
self.assertEqual(hosts[1].value, host_list[1].hostname)
def testHostReport_noExtraInfo(self, now):
now.return_value = TIMESTAMP
ndb_host = datastore_test_util.CreateHost(
'free', 'atl-1001.mtv', timestamp=TIMESTAMP)
report = device_info_reporter.HostReport(hosts=[ndb_host])
self.assertEqual(1, len(report.hosts))
self.assertEqual(0, len(report.hosts_checkin))
self.assertEqual(0, len(report.hosts_loas))
def testUpdateClusters_calculateHostCountByHarnessVersion(self):
cluster_name = 'cluster1'
host1 = datastore_test_util.CreateHost(cluster_name,
'host1.mtv',
lab_name='alab',
test_harness_version='v1')
host2 = datastore_test_util.CreateHost(cluster_name,
'host2.mtv',
lab_name='alab',
test_harness_version='v1')
host3 = datastore_test_util.CreateHost(cluster_name,
'host3.mtv',
lab_name='alab',
test_harness_version='v1')
host4 = datastore_test_util.CreateHost(cluster_name,
'host4.mtv',
lab_name='alab',
test_harness_version='v2')
host5 = datastore_test_util.CreateHost(cluster_name,
'host5.mtv',
lab_name='alab',
test_harness_version='v3a')
host6 = datastore_test_util.CreateHost(cluster_name,
'host6.mtv',
lab_name='alab',
test_harness_version='v3a')
host7 = datastore_test_util.CreateHost(cluster_name,
'host7.mtv',
lab_name='alab',
test_harness_version='v3a')
host8 = datastore_test_util.CreateHost(cluster_name,
'host8.mtv',
lab_name='alab',
test_harness_version='v3a')
host9 = datastore_test_util.CreateHost(cluster_name,
'host9.mtv',
lab_name='alab',
test_harness_version=None)
device_monitor._UpdateClusters(
[host1, host2, host3, host4, host5, host6, host7, host8, host9])
cluster = datastore_entities.ClusterInfo.get_by_id(cluster_name)
expected_harness_version_counts = {
'v1': 3,
'v2': 1,
'v3a': 4,
'UNKNOWN': 1,
}
self.assertDictEqual(expected_harness_version_counts,
cluster.host_count_by_harness_version)
def testHostReport_withoutEventTimestamp(self, now):
now.return_value = TIMESTAMP
# Create host list without timestamp
hosts = [
datastore_test_util.CreateHost('free', 'atl-1001.mtv', timestamp=None)
]
report = device_info_reporter.HostReport(hosts=hosts)
self.assertEqual(1, len(report.hosts))
self.assertEqual(1, len(report.hosts_checkin))
self.assertEqual(0, len(report.hosts_loas))
def testHostFlatExtraInfo(self):
host = datastore_test_util.CreateHost('acluster',
'ahost',
extra_info={
'key1': 'value1',
'key2': 'value2',
'host_ip': '1.2.3.4',
'label': 'v' * 1000,
})
host = host.key.get()
self.assertEqual(['host_ip:1.2.3.4', 'label:' + 'v' * 80],
host.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 testSyncHost_hideCloudTfHostWithoutLabName(self, mock_now):
"""Test _SyncHost will hide cloud tf host without lab name."""
now = datetime.datetime(2019, 11, 14, 10, 10)
before = now - datetime.timedelta(minutes=65)
mock_now.return_value = now
cloud_host = datastore_test_util.CreateHost('dockerized-tf-gke',
'cloud-tf-2345',
lab_name=None)
cloud_host.timestamp = before
cloud_host.put()
gke_host = datastore_test_util.CreateHost('dockerized-tf-gke',
'dockerized-tf-gke-2345',
lab_name=None)
gke_host.timestamp = before
gke_host.put()
should_sync = device_monitor._SyncHost(cloud_host.hostname)
self.assertFalse(should_sync)
should_sync = device_monitor._SyncHost(gke_host.hostname)
self.assertFalse(should_sync)
self.assertTrue(cloud_host.key.get().hidden)
self.assertTrue(gke_host.key.get().hidden)
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_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 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 testUpdateClusters_calculateHostUpdateStateSummaryPerVersion(self):
cluster_name = 'cluster1'
host1 = datastore_test_util.CreateHost(cluster_name,
'host1.mtv',
lab_name='alab')
host2 = datastore_test_util.CreateHost(cluster_name,
'host2.mtv',
lab_name='alab')
host3 = datastore_test_util.CreateHost(cluster_name,
'host3.mtv',
lab_name='alab')
host4 = datastore_test_util.CreateHost(cluster_name,
'host4.mtv',
lab_name='alab')
host5 = datastore_test_util.CreateHost(cluster_name,
'host5.mtv',
lab_name='alab')
host6 = datastore_test_util.CreateHost(cluster_name,
'host6.mtv',
lab_name='alab')
host7 = datastore_test_util.CreateHost(cluster_name,
'host7.mtv',
lab_name='alab')
host8 = datastore_test_util.CreateHost(cluster_name,
'host8.mtv',
lab_name='alab')
host9 = datastore_test_util.CreateHost(cluster_name,
'host9.mtv',
lab_name='alab')
datastore_test_util.CreateHostUpdateState(
host1.hostname,
state=api_messages.HostUpdateState.SYNCING,
target_version='v2')
datastore_test_util.CreateHostUpdateState(
host2.hostname,
state=api_messages.HostUpdateState.SYNCING,
target_version='v2')
datastore_test_util.CreateHostUpdateState(
host3.hostname,
state=api_messages.HostUpdateState.RESTARTING,
target_version='v2')
datastore_test_util.CreateHostUpdateState(
host4.hostname,
state=api_messages.HostUpdateState.ERRORED,
target_version='v2')
datastore_test_util.CreateHostUpdateState(
host5.hostname,
state=api_messages.HostUpdateState.PENDING,
target_version='v2')
datastore_test_util.CreateHostUpdateState(
host6.hostname,
state=api_messages.HostUpdateState.TIMED_OUT,
target_version='v2')
datastore_test_util.CreateHostUpdateState(
host7.hostname,
state=api_messages.HostUpdateState.SUCCEEDED,
target_version='v1')
datastore_test_util.CreateHostUpdateState(
host8.hostname,
state=api_messages.HostUpdateState.SHUTTING_DOWN,
target_version='v2')
datastore_test_util.CreateHostUpdateState(
host9.hostname,
state=api_messages.HostUpdateState.UNKNOWN,
target_version='v2')
device_monitor._UpdateClusters(
[host1, host2, host3, host4, host5, host6, host7, host8, host9])
cluster = datastore_entities.ClusterInfo.get_by_id(cluster_name)
version_to_summaries = {
summary.target_version: summary
for summary in cluster.host_update_state_summaries_by_version
}
self.assertEqual(1, version_to_summaries['v1'].total)
self.assertEqual(0, version_to_summaries['v1'].pending)
self.assertEqual(0, version_to_summaries['v1'].syncing)
self.assertEqual(0, version_to_summaries['v1'].shutting_down)
self.assertEqual(0, version_to_summaries['v1'].restarting)
self.assertEqual(0, version_to_summaries['v1'].errored)
self.assertEqual(0, version_to_summaries['v1'].timed_out)
self.assertEqual(1, version_to_summaries['v1'].succeeded)
self.assertEqual(0, version_to_summaries['v1'].unknown)
self.assertEqual(8, version_to_summaries['v2'].total)
self.assertEqual(1, version_to_summaries['v2'].pending)
self.assertEqual(2, version_to_summaries['v2'].syncing)
self.assertEqual(1, version_to_summaries['v2'].shutting_down)
self.assertEqual(1, version_to_summaries['v2'].restarting)
self.assertEqual(1, version_to_summaries['v2'].errored)
self.assertEqual(1, version_to_summaries['v2'].timed_out)
self.assertEqual(0, version_to_summaries['v2'].succeeded)
self.assertEqual(1, version_to_summaries['v2'].unknown)
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()
