OpenAPI: feature_api

api/api_specs.py

@@ -31,6 +31,7 @@
   ('availability_expectation', 'str'),
   ('blink_components', 'split_str'),
   ('enterprise_impact', 'int'),
+  ('shipping_year', 'int'),
   ('breaking_change', 'bool'),
   ('bug_url', 'link'),
   ('category', 'int'),

api/comments_api.py

@@ -15,37 +15,46 @@
 
 from typing import Any
 
-from framework import basehandlers
-from framework import permissions
+from chromestatus_openapi.models import (
+  Activity as ActivityModel,
+)
+from chromestatus_openapi.models import (
+  Amendment as AmendmentModel,
+)
+from chromestatus_openapi.models import (
+  CommentsRequest,
+  GetCommentsResponse,
+  PatchCommentRequest,
+  SuccessMessage,
+)
+
+from framework import basehandlers, permissions
+from internals import approval_defs, notifier, notifier_helpers, slo
 from internals.review_models import Activity, Amendment, Gate
-from internals import approval_defs
-from internals import notifier
-from internals import notifier_helpers
-from internals import slo
 
 
-def amendment_to_json_dict(amendment: Amendment) -> dict[str, Any]:
-  return {
-      'field_name': amendment.field_name,
-      'old_value': amendment.old_value.strip('[]'),
-      'new_value': amendment.new_value.strip('[]'),
-      }
+def amendment_to_OAM(amendment: Amendment) -> AmendmentModel:
+  return AmendmentModel(
+      field_name = amendment.field_name,
+      old_value = amendment.old_value.strip('[]'),
+      new_value = amendment.new_value.strip('[]'),
+  )
 
 
-def activity_to_json_dict(comment: Activity) -> dict[str, Any]:
+def activity_to_OAM(comment: Activity) -> ActivityModel:
   amendments_json = [
-      amendment_to_json_dict(amnd) for amnd in comment.amendments
+      amendment_to_OAM(amnd) for amnd in comment.amendments
       if amnd.old_value != 'None' or amnd.new_value != '[]']
-  return {
-      'comment_id': comment.key.id(),
-      'feature_id': comment.feature_id,
-      'gate_id': comment.gate_id,
-      'created': str(comment.created),  # YYYY-MM-DD HH:MM:SS.SSS
-      'author': comment.author,
-      'content': comment.content,
-      'deleted_by': comment.deleted_by,
-      'amendments': amendments_json,
-      }
+  return ActivityModel(
+      comment_id = comment.key.id(),
+      feature_id = comment.feature_id,
+      gate_id = comment.gate_id,
+      created = str(comment.created),  # YYYY-MM-DD HH:MM:SS.SSS
+      author = comment.author,
+      content = comment.content,
+      deleted_by = comment.deleted_by,
+      amendments = amendments_json,
+  )
 
 
 class CommentsAPI(basehandlers.APIHandler):
@@ -71,19 +80,20 @@ def do_get(self, **kwargs) -> dict[str, list[dict[str, Any]]]:
     comments = list(filter(
       lambda c: self._should_show_comment(c, user_email, is_admin), comments))
 
-    dicts = [activity_to_json_dict(c) for c in comments]
-    return {'comments': dicts}
+    dicts = [activity_to_OAM(c) for c in comments]
+    return GetCommentsResponse(comments=dicts).to_dict()
 
   def do_post(self, **kwargs) -> dict[str, str]:
     """Add a review comment and possibly set a approval value."""
     feature_id = kwargs['feature_id']
     gate_id = kwargs.get('gate_id', None)
     feature = self.get_specified_feature(feature_id=feature_id)
     user = self.get_current_user(required=True)
-    post_to_thread_type = self.get_param(
-        'postToThreadType', required=False)
 
-    comment_content = self.get_param('comment', required=False)
+    comment_request = CommentsRequest.from_dict(self.request.json)
+    comment_content = comment_request.comment
+    post_to_thread_type = comment_request.post_to_thread_type
+
     if comment_content:
       can_comment = (permissions.can_comment(user) or
                      permissions.can_edit_feature(user, feature_id))
@@ -114,22 +124,21 @@ def do_post(self, **kwargs) -> dict[str, str]:
           feature, gate_id, post_to_thread_type, user.email(), comment_content)
 
     # Callers don't use the JSON response for this API call.
-    return {'message': 'Done'}
+    return SuccessMessage(message='Done').to_dict()
 
   def do_patch(self, **kwargs) -> dict[str, str]:
-    comment_id = self.get_param('commentId', required=True)
-    comment: Activity = Activity.get_by_id(comment_id)
+    patch_request = PatchCommentRequest.from_dict(self.request.json)
+    comment: Activity = Activity.get_by_id(patch_request.comment_id)
 
     user = self.get_current_user(required=True)
     if not permissions.can_admin_site(user) and (
         comment and user.email() != comment.author):
       self.abort(403, msg='User does not have comment edit permissions')
 
-    is_undelete = self.get_param('isUndelete', required=True)
-    if is_undelete:
+    if patch_request.is_undelete:
       comment.deleted_by = None
     else:
       comment.deleted_by = user.email()
     comment.put()
 
-    return {'message': 'Done'}
+    return SuccessMessage(message='Done').to_dict()

api/comments_api_test.py

@@ -12,14 +12,17 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 import datetime
-import testing_config  # Must be imported before the module under test.
+from unittest import mock
 
 import flask
-from unittest import mock
 import werkzeug.exceptions  # Flask HTTP stuff.
+from chromestatus_openapi.models import (
+  Amendment as AmendmentModel,
+  Activity as ActivityModel,
+)
 
+import testing_config  # Must be imported before the module under test.
 from api import comments_api
 from internals.core_models import FeatureEntry
 from internals.review_models import Activity, Amendment, Gate, Vote
@@ -34,16 +37,16 @@ class CommentsConvertersTest(testing_config.CustomTestCase):
   def test_amendment_to_json_dict(self):
     amnd = Amendment(
         field_name='summary', old_value='foo', new_value='bar')
-    expected = dict(field_name='summary', old_value='foo', new_value='bar')
-    actual = comments_api.amendment_to_json_dict(amnd)
+    expected = AmendmentModel(field_name='summary', old_value='foo', new_value='bar')
+    actual = comments_api.amendment_to_OAM(amnd)
     self.assertEqual(expected, actual)
 
   def test_amendment_to_json_dict__arrays(self):
     """Arrays are shown without the brackets."""
     amnd = Amendment(
         field_name='summary', old_value='[1, 2]', new_value='[1, 2, 3]')
-    expected = dict(field_name='summary', old_value='1, 2', new_value='1, 2, 3')
-    actual = comments_api.amendment_to_json_dict(amnd)
+    expected = AmendmentModel(field_name='summary', old_value='1, 2', new_value='1, 2, 3')
+    actual = comments_api.amendment_to_OAM(amnd)
     self.assertEqual(expected, actual)
 
   def test_activity_to_json_dict(self):
@@ -56,8 +59,8 @@ def test_activity_to_json_dict(self):
         id=1, feature_id=123, gate_id=456, created=created,
         author='[email protected]', content='hello',
         amendments=[amnd_1, amnd_2])
-    actual = comments_api.activity_to_json_dict(act)
-    expected = {
+    actual = comments_api.activity_to_OAM(act)
+    expected_dict = {
       'comment_id': 1,
       'feature_id': 123,
       'gate_id': 456,
@@ -71,6 +74,7 @@ def test_activity_to_json_dict(self):
           'new_value': 'bar',
       }],
     }
+    expected = ActivityModel.from_dict(expected_dict)
     self.assertEqual(expected, actual)
 
 

api/component_users.py

@@ -13,6 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from chromestatus_openapi.models import ComponentUsersRequest
+
 from framework import basehandlers
 from framework import permissions
 from internals import user_models
@@ -47,16 +49,17 @@ def do_get(self, **kwargs):
 
   @permissions.require_admin_site
   def do_put(self, **kwargs) -> tuple[dict, int]:
-    params = self.request.get_json(force=True)
+    component_users_request = ComponentUsersRequest.from_dict(self.request.get_json(force=True))
     self.__update_subscribers_list(True, user_id=kwargs.get('user_id', None),
                                    blink_component_id=kwargs.get('component_id', None),
-                                   primary=params.get('owner'))
+                                   primary=component_users_request.owner)
     return {}, 200
 
   @permissions.require_admin_site
   def do_delete(self, **kwargs) -> tuple[dict, int]:
     params = self.request.get_json(force=True)
+    component_users_request = ComponentUsersRequest.from_dict(params)
     self.__update_subscribers_list(False, user_id=kwargs.get('user_id', None),
                                    blink_component_id=kwargs.get('component_id', None),
-                                   primary=params.get('owner'))
+                                   primary=component_users_request.owner)
     return {}, 200

api/converters.py

@@ -381,6 +381,7 @@ def feature_entry_to_json_verbose(
     'first_enterprise_notification_milestone': fe.first_enterprise_notification_milestone,
     'enterprise_impact': fe.enterprise_impact,
     'breaking_change': fe.breaking_change,
+    'shipping_year': fe.shipping_year,
     'flag_name': fe.flag_name,
     'finch_name': fe.finch_name,
     'non_finch_justification': fe.non_finch_justification,

api/converters_test.py

@@ -48,7 +48,7 @@ def setUp(self):
         updater_email='[email protected]', category=1,
         owner_emails=['[email protected]'], feature_type=0,
         editor_emails=['[email protected]', '[email protected]'],
-        impl_status_chrome=5, blink_components=['Blink'],
+        impl_status_chrome=5, blink_components=['Blink'], shipping_year=2024,
         spec_link='https://example.com/spec',
         sample_links=['https://example.com/samples'],
         screenshot_links=['https://example.com/screenshot'],
@@ -293,6 +293,7 @@ def test_feature_entry_to_json_verbose__normal(self):
       'unlisted': False,
       'api_spec': False,
       'enterprise_impact': ENTERPRISE_IMPACT_NONE,
+      'shipping_year': 2024,
       'breaking_change': False,
       'is_released': True,
       'category': 'Web Components',

api/feature_links_api.py

@@ -69,4 +69,4 @@ def do_get(self, **kwargs):
     type = self.request.args.get('type', None)
     is_error = self.get_bool_arg('is_error', None)
     if domain:
-      return FeatureLinksSample.from_dict(get_feature_links_samples(domain, type, is_error))
+      return FeatureLinksSample.from_dict(get_feature_links_samples(domain, type, is_error))

api/features_api.py

@@ -18,6 +18,8 @@
 from typing import Any
 from google.cloud import ndb
 
+from chromestatus_openapi.models import (VerboseFeatureDict as OneFeatureResponse, FeatureSearchResponse)
+
 from api import api_specs
 from api import converters
 from framework import basehandlers
@@ -113,7 +115,8 @@ def do_get(self, **kwargs):
     # way to handle this in a strictly-typed manner and implement it.
     feature_id = kwargs.get('feature_id', None)
     if feature_id:
-      return self.get_one_feature(feature_id)
+      feature = OneFeatureResponse.from_dict(self.get_one_feature(feature_id))
+      return feature.to_dict()
     return self.do_search()
 
   @permissions.require_create_feature

api/login_api.py

@@ -13,14 +13,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import logging
-
 import google.oauth2.id_token
+import werkzeug.exceptions
+from chromestatus_openapi.models import SignInRequest
 from google.auth.transport import requests
 
-from framework import basehandlers
-from framework import users
 import settings
+from framework import basehandlers, users
 
 
 class LoginAPI(basehandlers.APIHandler):
@@ -31,8 +30,14 @@ def do_get(self, **kwargs):
     self.abort(405, valid_methods=['POST'])
 
   def do_post(self, **kwargs):
-    token = self.get_param('credential')
-    message = "Unable to Authenticate. Please sign in again."
+    try:
+        request = SignInRequest.from_dict(self.request.json)
+        token = request.credential
+        if not token:
+            raise werkzeug.exceptions.BadRequest(description="Missing required field 'credential'")
+        message = "Unable to Authenticate. Please sign in again."
+    except ValueError:
+        message = "Invalid Request"
 
     try:
       idinfo = google.oauth2.id_token.verify_oauth2_token(