def testMergeEmptyString(self): """Test merging the empty or space only string.""" message = protojson.decode_message(test_util.OptionalMessage, '') self.assertEquals(test_util.OptionalMessage(), message) message = protojson.decode_message(test_util.OptionalMessage, ' ') self.assertEquals(test_util.OptionalMessage(), message)
def testListSummaries_filterReruns(self): test = self._createMockTest() test_run = self._createMockTestRunSummaries(test=test)[0] res = self.app.get('/_ah/api/mtt/v1/test_runs?prev_test_run_id=%s' % test_run.key.id()) self.assertEqual('200 OK', res.status) test_run_msg = protojson.decode_message(messages.TestRunSummaryList, res.body).test_runs self.assertEqual(test_run_msg, []) test_run_key = messages.ConvertToKey(ndb_models.TestRun, test_run.key.id()) retry_run = self._createMockTestRunSummaries( test=test, prev_test_run_key=test_run_key)[0] retry_run_msg = messages.Convert(retry_run, messages.TestRunSummary) separate_retry = self._createMockTestRunSummaries( test=test, prev_test_run_key=test_run_key)[0] separate_retry_msg = messages.Convert(separate_retry, messages.TestRunSummary) res = self.app.get('/_ah/api/mtt/v1/test_runs?prev_test_run_id=%s' % test_run.key.id()) test_run_msg = protojson.decode_message(messages.TestRunSummaryList, res.body).test_runs self.assertEqual(test_run_msg[0].id, separate_retry_msg.id) self.assertEqual(test_run_msg[1].id, retry_run_msg.id)
def testListSummaries(self): test = self._createMockTest() for i in range(1, 10): self._createMockTestRuns(test, device_specs=[str(i)], count=1) # fetch first page (5 results, run count 9 to 5, has more) res = self.app.get('/_ah/api/mtt/v1/test_runs?max_results=5') self.assertEqual('200 OK', res.status) first_page = protojson.decode_message(messages.TestRunSummaryList, res.body) self.assertLen(first_page.test_runs, 5) self.assertIsNone(first_page.prev_page_token) # no previous runs self.assertIsNotNone(first_page.next_page_token) # has following runs self.assertEqual(first_page.test_runs[0].device_specs, ['9']) self.assertEqual(first_page.test_runs[4].device_specs, ['5']) # fetch next page (4 results, run count 4 to 1, last page) res = self.app.get( '/_ah/api/mtt/v1/test_runs?max_results=5&page_token=%s' % first_page.next_page_token) self.assertEqual('200 OK', res.status) next_page = protojson.decode_message(messages.TestRunSummaryList, res.body) self.assertLen(next_page.test_runs, 4) self.assertIsNotNone(next_page.prev_page_token) # has previous runs self.assertIsNone(next_page.next_page_token) # no following runs self.assertEqual(next_page.test_runs[0].device_specs, ['4']) self.assertEqual(next_page.test_runs[3].device_specs, ['1']) # fetch previous page (same as first page) res = self.app.get( '/_ah/api/mtt/v1/test_runs?max_results=5&page_token=%s&backwards=true' % next_page.prev_page_token) self.assertEqual('200 OK', res.status) prev_page = protojson.decode_message(messages.TestRunSummaryList, res.body) self.assertEqual(first_page, prev_page)
def testList_filter(self, mock_get_remote_config_set_infos): imported_config = self._CreateImportedConfig() nonimported_config = self._CreateNonImportedConfig() updatable_config_old, updatable_config_new = self._CreateUpdatableConfig( ) imported_message = self._CreateConfigSetInfoMessage( imported_config, ndb_models.ConfigSetStatus.IMPORTED) nonimported_message = self._CreateConfigSetInfoMessage( nonimported_config, ndb_models.ConfigSetStatus.NOT_IMPORTED) updatable_message_old = self._CreateConfigSetInfoMessage( updatable_config_old, ndb_models.ConfigSetStatus.UPDATABLE) updatable_message_new = self._CreateConfigSetInfoMessage( updatable_config_new, ndb_models.ConfigSetStatus.UPDATABLE) mock_get_remote_config_set_infos.return_value = [ imported_message, nonimported_message, updatable_message_new ] args = 'include_remote=true&statuses=IMPORTED&statuses=UPDATABLE' res = self.app.get('/_ah/api/mtt/v1/config_sets?%s' % args) res_msg = protojson.decode_message(messages.ConfigSetInfoList, res.body) self.assertEqual(len(res_msg.config_set_infos), 2) self.assertEqual(imported_message, res_msg.config_set_infos[0]) self.assertEqual(updatable_message_old, res_msg.config_set_infos[1]) args = 'include_remote=true&statuses=NOT_IMPORTED' res = self.app.get('/_ah/api/mtt/v1/config_sets?%s' % args) res_msg = protojson.decode_message(messages.ConfigSetInfoList, res.body) self.assertEqual(len(res_msg.config_set_infos), 1) self.assertEqual(nonimported_message, res_msg.config_set_infos[0])
def testUpdate(self, mock_schedule_test_plan_cron_job): """Tests test_plans.update API with invalid data.""" test_plan = _CreateMockTestPlan('foo') test_plan_id = test_plan.key.id() data = { 'name': 'bar', 'test_run_configs': [{ 'test_id': self.mock_test_id, 'cluster': 'cluster', 'run_target': 'run_target', }], 'test_resource_pipes': [{ 'name': 'bar', 'url': self.mock_test_resource_url, }], 'before_device_action_ids': [ self.mock_device_action_id, ] } res = self.app.put_json('/_ah/api/mtt/v1/test_plans/%s' % test_plan_id, data) msg = protojson.decode_message(messages.TestPlan, res.body) self.assertEqual(test_plan_id, int(msg.id)) test_plan = ndb_models.TestPlan.get_by_id(test_plan_id) self.assertIsNotNone(test_plan) self._VerifyTestPlan(data, test_plan) mock_schedule_test_plan_cron_job.assert_called_with(test_plan_id)
def testNewNote_withExisting(self): """Tests adding a note to a cluster when one already exists.""" user = '******' timestamp = datetime.datetime(2015, 10, 18, 20, 46) message = 'The Message' api_request = {'cluster_id': 'free', 'user': user, 'timestamp': timestamp.isoformat(), 'message': message } api_response = self.testapp.post_json('/_ah/api/ClusterApi.NewNote', api_request) self.assertEqual('200 OK', api_response.status) # Query the same cluster again. Notes should be sorted. api_request = {'cluster_id': 'free', 'include_notes': True} api_response = self.testapp.post_json('/_ah/api/ClusterApi.GetCluster', api_request) cluster_info = protojson.decode_message(api_messages.ClusterInfo, api_response.body) self.assertEqual(2, len(cluster_info.notes)) self.assertEqual(user, cluster_info.notes[0].user) self.assertEqual(timestamp, cluster_info.notes[0].timestamp) self.assertEqual(message, cluster_info.notes[0].message) self.assertEqual(self.note.user, cluster_info.notes[1].user) self.assertEqual(self.note.timestamp, cluster_info.notes[1].timestamp) self.assertEqual(self.note.message, cluster_info.notes[1].message)
def testGetCluster_includeHosts(self): """Tests GetCluster returns hosts in order with their devices.""" api_request = {'cluster_id': 'free', 'include_hosts': True} api_response = self.testapp.post_json( '/_ah/api/ClusterApi.GetCluster', api_request) cluster_info = protojson.decode_message(api_messages.ClusterInfo, api_response.body) self.assertEqual('200 OK', api_response.status) self.assertEqual('free', cluster_info.cluster_id) self.assertEqual(2, len(cluster_info.host_infos)) self.assertEqual('host_0', cluster_info.host_infos[0].hostname) self.assertEqual(1, len(cluster_info.host_infos[0].device_infos)) self.assertEqual('device_0', cluster_info.host_infos[0].device_infos[0].device_serial) self.assertEqual('100', cluster_info.host_infos[0].device_infos[0].battery_level) self.assertIsNone(cluster_info.host_infos[0].device_infos[0].timestamp) self.assertEqual('host_1', cluster_info.host_infos[1].hostname) self.assertEqual(1, len(cluster_info.host_infos[1].device_infos)) self.assertEqual('device_1', cluster_info.host_infos[1].device_infos[0].device_serial) self.assertEqual(self.TIMESTAMP, cluster_info.host_infos[1].device_infos[0].timestamp) self.assertEqual(0, len(cluster_info.notes)) self.assertItemsEqual(['shamu', 'flounder'], [r.name for r in cluster_info.run_targets])
def testBuildReport_noDates(self, mock_record_groups): # Test BuildReport with no given dates record_groups_0 = [ report_api.RecordGroup(groupByField='field', groupByValue='a', count=1, total=2) ] record_groups_1 = [ report_api.RecordGroup(groupByField='field', groupByValue='b', count=3, total=3) ] # Since no dates are provided, only record_groups_0 should be returned mock_record_groups.side_effect = [record_groups_0, record_groups_1] api_request = { 'groupByKey': 'product', 'states': ['Available', 'Allocated'], } api_response = self.testapp.post_json('/_ah/api/ReportApi.BuildReport', api_request) self.assertEqual('200 OK', api_response.status) report = protojson.decode_message(report_api.Report, api_response.body) daily_records = report.dailyRecords self.assertEqual(1, len(daily_records)) self.assertEqual(record_groups_0, daily_records[0].recordGroups)
def testTestListHarnessImages_withFilter_goldenImages(self): api_request = { 'count': 4, 'tag_prefix': 'golden_tradefed', } api_response = self.testapp.post_json( '/_ah/api/TestHarnessImageApi.ListTestHarnessImages', api_request) image_collection = protojson.decode_message( api_messages.TestHarnessImageMetadataCollection, api_response.body) self.assertEqual('200 OK', api_response.status) images = image_collection.images next_cursor = image_collection.next_cursor self.assertLen(images, 3) self.assertIsNone(next_cursor) self.assertTrue( _CheckTestHarnessImageEntityAndApiMessageEqual( self._entities[1], images[0])) self.assertTrue( _CheckTestHarnessImageEntityAndApiMessageEqual( self._entities[2], images[1])) self.assertTrue( _CheckTestHarnessImageEntityAndApiMessageEqual( self._entities[3], images[2]))
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 testListDeviceStates(self): """Tests ListDeviceStates.""" api_request = {'type': 'DEVICE_STATE'} api_response = self.testapp.post_json( '/_ah/api/FilterHintApi.ListFilterHints', api_request) device_state_collection = protojson.decode_message( api_messages.FilterHintCollection, api_response.body) self.assertEqual('200 OK', api_response.status) self.assertEqual(17, len(device_state_collection.filter_hints)) states = list(device_state_collection.filter_hints) self.assertEqual([s.value for s in states], [ common.DeviceState.ALLOCATED, common.DeviceState.AVAILABLE, common.DeviceState.CHECKING, common.DeviceState.FASTBOOT, common.DeviceState.GONE, common.DeviceState.IGNORED, common.DeviceState.UNAVAILABLE, common.DeviceState.UNKNOWN, common.DeviceState.INIT, common.DeviceState.DYING, common.DeviceState.MISSING, common.DeviceState.PREPPING, common.DeviceState.DIRTY, common.DeviceState.LAMEDUCK, common.DeviceState.IDLE, common.DeviceState.BUSY, common.DeviceState.OFFLINE, ])
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 protorpc_to_endpoints_error(self, status, body): """Convert a ProtoRPC error to the format expected by Google Endpoints. If the body does not contain an ProtoRPC message in state APPLICATION_ERROR the status and body will be returned unchanged. Args: status: HTTP status of the response from the backend body: JSON-encoded error in format expected by Endpoints frontend. Returns: Tuple of (http status, body) """ try: rpc_error = protojson.decode_message(remote.RpcStatus, body) except (ValueError, messages.ValidationError): rpc_error = remote.RpcStatus() if rpc_error.state == remote.RpcStatus.State.APPLICATION_ERROR: error_class = _ERROR_NAME_MAP.get(rpc_error.error_name) if error_class: status, body = self.__write_error(error_class.http_status, rpc_error.error_message) return status, body
def testCqStats(self): project = 'chromium' cron_app = webtest.TestApp( webapp2.WSGIApplication([ ('/check-cq', cron.CheckCQHandler), ]) ) cron_app.get('/check-cq') cq_data = self._make_api_call( 'cq_stats_get', params={'project': project}, ).json generated = {} for name, klass in (('single_run_data', models.CqStat), ('queue_time_data', models.CqTimeInQueueForPatchStat), ('total_time_data', models.CqTotalTimeForPatchStat)): generated[name] = [ protojson.decode_message(klass.ProtoModel(), json.dumps(x)) for x in cq_data[name]] expected = controller.get_cq_stats(project) for key in expected: expected[key] = [x.ToMessage() for x in expected[key]] self.assertEqual(generated, expected)
def testTestListHarnessImages_allInOnePage(self): api_request = {'count': 4} api_response = self.testapp.post_json( '/_ah/api/TestHarnessImageApi.ListTestHarnessImages', api_request) image_collection = protojson.decode_message( api_messages.TestHarnessImageMetadataCollection, api_response.body) self.assertEqual('200 OK', api_response.status) images = image_collection.images next_cursor = image_collection.next_cursor self.assertLen(images, 4) self.assertIsNone(next_cursor) self.assertTrue( _CheckTestHarnessImageEntityAndApiMessageEqual( self._entities[0], images[0])) self.assertTrue( _CheckTestHarnessImageEntityAndApiMessageEqual( self._entities[1], images[1])) self.assertTrue( _CheckTestHarnessImageEntityAndApiMessageEqual( self._entities[2], images[2])) self.assertTrue( _CheckTestHarnessImageEntityAndApiMessageEqual( self._entities[3], images[3]))
def testCreate(self, mock_schedule_test_plan_cron_job): """Tests test_plans.create API.""" data = { 'name': 'foo', 'cron_exp': '0 * * * *', 'test_run_configs': [{ 'test_id': self.mock_test_id, 'cluster': 'cluster', 'run_target': 'run_target', }], 'test_resource_pipes': [{ 'name': 'bar', 'url': self.mock_test_resource_url, }], 'before_device_action_ids': [ self.mock_device_action_id, ] } res = self.app.post_json('/_ah/api/mtt/v1/test_plans', data) msg = protojson.decode_message(messages.TestPlan, res.body) test_plan_id = int(msg.id) test_plan = ndb_models.TestPlan.get_by_id(test_plan_id) self._VerifyTestPlan(data, test_plan) mock_schedule_test_plan_cron_job.assert_called_with(test_plan_id)
def testNullValues(self): """Test that null values overwrite existing values.""" self.assertEquals(MyMessage(), protojson.decode_message(MyMessage, ('{"an_integer": null,' ' "a_nested": null' '}')))
def testListHostUpdateStates(self): """Tests ListHostUpdateStates.""" api_request = {'type': 'UPDATE_STATE'} api_response = self.testapp.post_json( '/_ah/api/FilterHintApi.ListFilterHints', api_request) host_state_collection = protojson.decode_message( api_messages.FilterHintCollection, api_response.body) self.assertEqual('200 OK', api_response.status) self.assertEqual(8, len(host_state_collection.filter_hints)) states = list(host_state_collection.filter_hints) self.assertEqual(states[0].value, api_messages.HostUpdateState.UNKNOWN.name) self.assertEqual(states[1].value, api_messages.HostUpdateState.PENDING.name) self.assertEqual(states[2].value, api_messages.HostUpdateState.SYNCING.name) self.assertEqual(states[3].value, api_messages.HostUpdateState.SHUTTING_DOWN.name) self.assertEqual(states[4].value, api_messages.HostUpdateState.RESTARTING.name) self.assertEqual(states[5].value, api_messages.HostUpdateState.TIMED_OUT.name) self.assertEqual(states[6].value, api_messages.HostUpdateState.ERRORED.name) self.assertEqual(states[7].value, api_messages.HostUpdateState.SUCCEEDED.name)
def testGetMetadata_returnsCompletedAttempts(self, mock_get_request): # request w/ RUNNING and COMPLETED attempts mock_request = mock.MagicMock() mock_get_request.return_value = mock_request running_attempt = self._createAttempt(CommandState.RUNNING) completed_attempt = self._createAttempt(CommandState.COMPLETED) mock_request.command_attempts = [running_attempt, completed_attempt] test = self._createMockTest() test_run = self._createMockTestRuns(test=test)[0] test_run.request_id = 'request' test_run.put() res = self.app.get( '/_ah/api/mtt/v1/test_runs/%s/metadata' % test_run.key.id()) # metadata is sent back w/ only COMPLETED attempts metadata = protojson.decode_message(messages.TestRunMetadataList, res.body) expected = messages.TestRunMetadataList( test_runs=[ messages.TestRunMetadata( test_run=messages.Convert(test_run, messages.TestRun), command_attempts=[completed_attempt]) ], server_version=env.VERSION) self.assertEqual(expected, metadata)
def testBuildReport(self, mock_record_groups): # Test BuildReport record_groups_0 = [ report_api.RecordGroup(groupByField='field', groupByValue='a', count=1, total=2) ] record_groups_1 = [ report_api.RecordGroup(groupByField='field', groupByValue='b', count=3, total=3) ] mock_record_groups.side_effect = [record_groups_0, record_groups_1] api_request = { 'groupByKey': 'product_variant', 'startDate': DATE_0.isoformat(), 'endDate': DATE_1.isoformat(), 'states': ['Available', 'Allocated'], } api_response = self.testapp.post_json('/_ah/api/ReportApi.BuildReport', api_request) self.assertEqual('200 OK', api_response.status) report = protojson.decode_message(report_api.Report, api_response.body) daily_records = report.dailyRecords self.assertEqual(2, len(daily_records)) self.assertEqual(record_groups_0, daily_records[0].recordGroups) self.assertEqual(record_groups_1, daily_records[1].recordGroups)
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 testAuthAccountPrinciples_jumpHostNoAccess(self): datastore_test_util.CreateHostConfig( 'mock.host.google.com', 'foo-lab', inventory_groups=['jump']) datastore_test_util.CreateHostGroupConfig( 'bar-group', 'foo-lab', account_principals={ 'bar-admin': { 'principals': ['principalA', 'principalB'] } }) datastore_test_util.CreateHostGroupConfig('bar-group2', 'foo-lab') acl_service.CheckMembership = mock.MagicMock(return_value=False) api_request = { 'hostname': 'mock.host.google.com', 'host_account': 'android-test', 'user_name': 'mock-user' } api_response = self.testapp.post_json('/_ah/api/AclApi.CheckSshAccessible', api_request) account_principals = protojson.decode_message(api_messages.AclCheckResult, api_response.body) self.assertEqual('200 OK', api_response.status) self.assertFalse(account_principals.has_access) acl_service.CheckMembership.assert_has_calls([ mock.call('mock-user', 'principalA'), mock.call('mock-user', 'principalB') ])
def testCreate_stripId(self): """Tests that new actions have new IDs.""" data = {'id': '1', 'name': 'created', 'hook_class_name': 'simple'} response = self.app.post_json('/_ah/api/mtt/v1/test_run_actions', data) action = protojson.decode_message(messages.TestRunAction, response.body) self.assertNotEqual('1', action.id)
def testGetMetadata_remoteAncestry(self, mock_open_file): # create hierarchy of test_runs test = self._createMockTest() child, parent = self._createMockTestRuns(test=test, count=2) with tempfile.NamedTemporaryFile(suffix='.zip') as tmp_stream: # write parent metadata to a temporary zip file with zipfile.ZipFile(tmp_stream, 'w') as context_file: res = self.app.get('/_ah/api/mtt/v1/test_runs/%s/metadata' % parent.key.id()) context_file.writestr('mtt.json', res.body) tmp_stream.seek(0) mock_open_file.return_value = tmp_stream # mark child as a remote return child.prev_test_context = ndb_models.TestContextObj(test_resources=[ ndb_models.TestResourceObj(name='mtt.json', url='url') ]) child.put() res = self.app.get('/_ah/api/mtt/v1/test_runs/%s/metadata' % child.key.id()) # metadata is sent back w/ ordered ancestry information metadata = protojson.decode_message(messages.TestRunMetadataList, res.body) expected = messages.TestRunMetadataList( test_runs=[ messages.TestRunMetadata( test_run=messages.Convert(child, messages.TestRun)), messages.TestRunMetadata( test_run=messages.Convert(parent, messages.TestRun)) ], server_version=env.VERSION) self.assertEqual(expected, metadata)
def testCqStats(self): project = 'chromium' cron_app = webtest.TestApp( webapp2.WSGIApplication([ ('/check-cq', cron.CheckCQHandler), ])) cron_app.get('/check-cq') cq_data = self._make_api_call( 'cq_stats_get', params={ 'project': project }, ).json generated = {} for name, klass in (('single_run_data', models.CqStat), ('queue_time_data', models.CqTimeInQueueForPatchStat), ('total_time_data', models.CqTotalTimeForPatchStat)): generated[name] = [ protojson.decode_message(klass.ProtoModel(), json.dumps(x)) for x in cq_data[name] ] expected = controller.get_cq_stats(project) for key in expected: expected[key] = [x.ToMessage() for x in expected[key]] self.assertEqual(generated, expected)
def testGetMetadata_ancestry(self, mock_get_request): mock_get_request.return_value = mock.MagicMock() test = self._createMockTest() # create hierarchy of test_runs child, parent, grandparent = self._createMockTestRuns(test=test, count=3) child.prev_test_run_key = parent.key child.prev_test_context = ndb_models.TestContextObj() child.put() parent.prev_test_run_key = grandparent.key parent.prev_test_context = ndb_models.TestContextObj() parent.put() res = self.app.get('/_ah/api/mtt/v1/test_runs/%s/metadata' % child.key.id()) # metadata is sent back w/ ordered ancestry information metadata = protojson.decode_message(messages.TestRunMetadataList, res.body) expected = messages.TestRunMetadataList( test_runs=[ messages.TestRunMetadata( test_run=messages.Convert(child, messages.TestRun)), messages.TestRunMetadata( test_run=messages.Convert(parent, messages.TestRun)), messages.TestRunMetadata( test_run=messages.Convert(grandparent, messages.TestRun)) ], server_version=env.VERSION) self.assertEqual(expected, metadata)
def testGet(self): response = self.app.get('/_ah/api/mtt/v1/build_channel_providers/Mock') res = protojson.decode_message(messages.BuildChannelProvider, response.body) self.assertEqual(res.name, 'Mock') self.assertLen(res.option_defs, 1) self.assertEqual(res.option_defs[0].name, 'mock_option')
def testNullValues(self): """Test that null values overwrite existing values.""" self.assertEquals( MyMessage(), protojson.decode_message(MyMessage, ('{"an_integer": null,' ' "a_nested": null' '}')))
def DoRequest(self, path, request, response_type, reg_path='/protorpc'): stdin = sys.stdin stdout = sys.stdout environ = os.environ try: sys.stdin = cStringIO.StringIO(protojson.encode_message(request)) sys.stdout = cStringIO.StringIO() os.environ = webapp_test_util.GetDefaultEnvironment() os.environ['PATH_INFO'] = path os.environ['REQUEST_METHOD'] = 'POST' os.environ['CONTENT_TYPE'] = 'application/json' os.environ['wsgi.input'] = sys.stdin os.environ['wsgi.output'] = sys.stdout os.environ['CONTENT_LENGTH'] = len(sys.stdin.getvalue()) service_handlers.run_services( [('/my_service', GetCalled.new_factory(self))], reg_path) header, body = sys.stdout.getvalue().split('\n\n', 1) return (header.split('\n')[0], protojson.decode_message(response_type, body)) finally: sys.stdin = stdin sys.stdout = stdout os.environ = environ
def GetRequestInvocationStatus( request_id: int) -> api_messages.InvocationStatus: """Fetches the invocation status for a request.""" res = _GetAPIClient().requests().invocationStatus().get( request_id=request_id).execute() return protojson.decode_message( # pytype: disable=module-attr api_messages.InvocationStatus, json.dumps(res))
def testProtojsonUnrecognizedNull(self): """Test that unrecognized fields that are None are skipped.""" decoded = protojson.decode_message( MyMessage, '{"an_integer": 1, "unrecognized_null": null}') self.assertEquals(decoded.an_integer, 1) self.assertEquals(decoded.all_unrecognized_fields(), [])
def testLeaseHostTasks_inconsistencyCommand(self, ensure_consistency): ensure_consistency.return_value = False self._AddCommand(REQUEST_ID, '2', 'command', 'cluster', 'run_target1') request = { 'hostname': 'hostname', 'cluster': 'cluster', 'device_infos': [ { 'device_serial': 'd1', 'hostname': 'hostname', 'run_target': 'run_target1', 'state': common.DeviceState.AVAILABLE, }, ], 'next_cluster_ids': ['cluster2', 'cluster3'] } response = self.testapp.post_json( '/_ah/api/CommandTaskApi.LeaseHostTasks', request) self.assertEqual('200 OK', response.status) task_list = protojson.decode_message(command_task_api.CommandTaskList, response.body) self.assertEqual(0, len(task_list.tasks)) ensure_consistency.assert_called_once_with( REQUEST_ID, '2', '%s-2-0' % REQUEST_ID)
def testNumericEnumeration(self): """Test that numbers work for enum values.""" message = protojson.decode_message(MyMessage, '{"an_enum": 2}') expected_message = MyMessage() expected_message.an_enum = MyMessage.Color.GREEN self.assertEquals(expected_message, message)
def testAlphaEnumeration(self): """Test that alpha enum values work.""" message = protojson.decode_message(MyMessage, '{"an_enum": "RED"}') expected_message = MyMessage() expected_message.an_enum = MyMessage.Color.RED self.assertEquals(expected_message, message)
def testListTestCaseResults_nameFilter(self): """Tests that test case results can be filtered by name.""" path = 'modules/module_3/test_cases?name=sT_2' response = self.app.get('/_ah/api/mtt/v1/test_results/' + path) result_list = protojson.decode_message( messages.TestCaseResultList, response.body) self.assertLen(result_list.results, 1) self.assertEqual('test_2', result_list.results[0].name)
def testConvertIntegerToFloat(self): """Test that integers passed in to float fields are converted. This is necessary because JSON outputs integers for numbers with 0 decimals. """ message = protojson.decode_message(MyMessage, '{"a_float": 10}') self.assertTrue(isinstance(message.a_float, float)) self.assertEquals(10.0, message.a_float)
def testProtojsonUnrecognizedFieldName(self): """Test that unrecognized fields are saved and can be accessed.""" decoded = protojson.decode_message(MyMessage, ('{"an_integer": 1, "unknown_val": 2}')) self.assertEquals(decoded.an_integer, 1) self.assertEquals(1, len(decoded.all_unrecognized_fields())) self.assertEquals('unknown_val', decoded.all_unrecognized_fields()[0]) self.assertEquals((2, messages.Variant.INT64), decoded.get_unrecognized_field_info('unknown_val'))
def testDecodeDateTime(self): for datetime_string, datetime_vals in ( ('2012-09-30T15:31:50.262', (2012, 9, 30, 15, 31, 50, 262000)), ('2012-09-30T15:31:50', (2012, 9, 30, 15, 31, 50, 0))): message = protojson.decode_message( MyMessage, '{"a_datetime": "%s"}' % datetime_string) expected_message = MyMessage( a_datetime=datetime.datetime(*datetime_vals)) self.assertEquals(expected_message, message)
def testDecodeRepeatedDateTime(self): message = protojson.decode_message( MyMessage, '{"a_repeated_datetime": ["2012-09-30T15:31:50.262", ' '"2010-01-21T09:52:00", "2000-01-01T01:00:59.999999"]}') expected_message = MyMessage( a_repeated_datetime=[ datetime.datetime(2012, 9, 30, 15, 31, 50, 262000), datetime.datetime(2010, 1, 21, 9, 52), datetime.datetime(2000, 1, 1, 1, 0, 59, 999999)]) self.assertEquals(expected_message, message)
def message_from_json(message_type, value): '''Returns an instance of a protorpc `Message` class. :param message_type: Protorpc `Message` class. :param value: JSON string to decode to a `Message`. ''' if isinstance(value, str): value = value elif isinstance(value, dict): value = dumps(value) else: raise JsonValueError('Value must be a json str or dict.') return protojson.decode_message(message_type, value)
def process(self, request, container, fallback=None): from protorpc import protojson, messages try: result = protojson.decode_message(container, request.body) self.errors = None except messages.ValidationError as e: result = container() self.errors = [e.message] self.container = result self.fallback = fallback return self
def testConvertStringToNumbers(self): """Test that strings passed to integer fields are converted.""" message = protojson.decode_message(MyMessage, """{"an_integer": "10", "a_float": "3.5", "a_repeated": ["1", "2"], "a_repeated_float": ["1.5", "2", 10] }""") self.assertEquals(MyMessage(an_integer=10, a_float=3.5, a_repeated=[1, 2], a_repeated_float=[1.5, 2.0, 10.0]), message)
def load_quota_config(quota_config_path=QUOTA_CONFIG_PATH): """Load quota configuration from from file. Args: quota_config_path: Quota to configuration file. Contents of file must be a JSON encoded ProtoRPC message of the format defined by quota.services.QuotaConfig. Returns: quota.services.QuotaConfig instance with contents parsed from quota file. """ with open(quota_config_path) as quota_config_file: encoded_config = quota_config_file.read() return protojson.decode_message(services.QuotaConfig, encoded_config)
def process(self, request, container, fallback=None): from protorpc import protojson, messages try: self.partial_fields = json.loads(request.body).keys() result = protojson.decode_message(container, request.body) self.errors = None except (messages.ValidationError, ValueError) as e: result = container() self.errors = [e.message] self.partial_fields = None self.container = result self.fallback = fallback return self
def _get_stats_to_download(self, locales): # 'stats' maps the service name to a mapping of languages to stats. stats = self.pod.read_yaml(Translator.TRANSLATOR_STATS_PATH) if self.KIND not in stats: self.pod.logger.info('Nothing found to download from {}'.format(self.KIND)) return stats_to_download = stats[self.KIND] if locales: stats_to_download = dict([(lang, stat) for (lang, stat) in stats_to_download.iteritems() if lang in locales]) for lang, stat in stats_to_download.iteritems(): stat['lang'] = lang stat = json.dumps(stat) stat_message = protojson.decode_message(TranslatorStat, stat) stats_to_download[lang] = stat_message return stats_to_download
def testProtojsonUnrecognizedFieldNumber(self): """Test that unrecognized fields are saved and can be accessed.""" decoded = protojson.decode_message( MyMessage, '{"an_integer": 1, "1001": "unknown", "-123": "negative", ' '"456_mixed": 2}') self.assertEquals(decoded.an_integer, 1) self.assertEquals(3, len(decoded.all_unrecognized_fields())) self.assertTrue(1001 in decoded.all_unrecognized_fields()) self.assertEquals(('unknown', messages.Variant.STRING), decoded.get_unrecognized_field_info(1001)) self.assertTrue('-123' in decoded.all_unrecognized_fields()) self.assertEquals(('negative', messages.Variant.STRING), decoded.get_unrecognized_field_info('-123')) self.assertTrue('456_mixed' in decoded.all_unrecognized_fields()) self.assertEquals((2, messages.Variant.INT64), decoded.get_unrecognized_field_info('456_mixed'))
def testUnrecognizedFieldVariants(self): """Test that unrecognized fields are mapped to the right variants.""" for encoded, expected_variant in ( ('{"an_integer": 1, "unknown_val": 2}', messages.Variant.INT64), ('{"an_integer": 1, "unknown_val": 2.0}', messages.Variant.DOUBLE), ('{"an_integer": 1, "unknown_val": "string value"}', messages.Variant.STRING), ('{"an_integer": 1, "unknown_val": [1, 2, 3]}', messages.Variant.INT64), ('{"an_integer": 1, "unknown_val": [1, 2.0, 3]}', messages.Variant.DOUBLE), ('{"an_integer": 1, "unknown_val": [1, "foo", 3]}', messages.Variant.STRING), ('{"an_integer": 1, "unknown_val": true}', messages.Variant.BOOL)): decoded = protojson.decode_message(MyMessage, encoded) self.assertEquals(decoded.an_integer, 1) self.assertEquals(1, len(decoded.all_unrecognized_fields())) self.assertEquals('unknown_val', decoded.all_unrecognized_fields()[0]) _, decoded_variant = decoded.get_unrecognized_field_info('unknown_val') self.assertEquals(expected_variant, decoded_variant)
def from_string(cls, content): return protojson.decode_message(messages.IndexMessage, content)
def config_from_json(preprocessor_class, content): config_class = preprocessor_class.Config return protojson.decode_message(config_class, content)
def decode_json_to_message(message_type, value): return decode_message(message_type, dumps(value))
def parse_config(cls, config): """Parse the config into the protobuf.""" return protojson.decode_message( cls.Config, json.dumps(config))
def config_from_json(deployment_class, content): config_class = deployment_class.Config return protojson.decode_message(config_class, content)
def DecodeProto(data): return protojson.decode_message(request_type, data)
def config_from_json(config_class, config): config = json.dumps(config) return protojson.decode_message(config_class, config)
def testDecodeRepeatedCustom(self): message = protojson.decode_message( MyMessage, '{"a_repeated_custom": [1, 2, 3]}') self.assertEquals(MyMessage(a_repeated_custom=[1, 2, 3]), message)
def message_from_json_str(message_type, value): return decode_message(message_type, value)
def testDecodeCustom(self): message = protojson.decode_message(MyMessage, '{"a_custom": 1}') self.assertEquals(MyMessage(a_custom=1), message)