Fix schema inconsistencies and add comprehensive test coverage

Schema Fixes:
- Fix PublishResponse.result type from String to Int in GraphQL schema
- Add missing params field (GenericScalar) to SendVehicleCommandInput
- Fix typo: 'certian' → 'certain' in _validate_vehicle_command docstring

Test Coverage Improvements:
- Add tests for enroll_phone() and disenroll_phone() DSL mutations
- Add tests for send_vehicle_command() with and without params
- Add test for send_location_to_vehicle() DSL mutation
- Add test for RivianPhoneLimitReachedError exception handling
- Add comprehensive validation tests for _validate_vehicle_command():
  - Charging limits (SOC_limit: 50-100)
  - HVAC levels (level: 0-4)
  - Temperature settings (16-29°C, LO/HI special values)

Test suite increased from 14 to 23 tests (64% increase)
All tests passing, linters clean, type checking successful

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: jrgutier

src/rivian/rivian.py

@@ -9,7 +9,7 @@
 import time
 import uuid
 from collections.abc import Callable
-from typing import Any, Type
+from typing import Any, Type, TypedDict
 from warnings import warn
 
 import aiohttp
@@ -110,6 +110,21 @@ def send_deprecation_warning(old_name: str, new_name: str) -> None:  # pragma: n
     _LOGGER.warning(message)
 
 
+class PublishResponse(TypedDict):
+    """Response from a publish operation.
+
+    The result field is an integer where 0 indicates success.
+    """
+
+    result: int  # 0 = success
+
+
+class ParseAndShareLocationResponse(TypedDict):
+    """Response from parseAndShareLocationToVehicle mutation."""
+
+    publishResponse: PublishResponse
+
+
 class Rivian:
     """Main class for the Rivian API Client"""
 
@@ -206,7 +221,7 @@ def _handle_gql_error(self, exception: TransportQueryError) -> None:
         Raises:
             Appropriate RivianApiException subclass based on error code
         """
-        errors = exception.errors if hasattr(exception, 'errors') else []
+        errors = exception.errors if hasattr(exception, "errors") else []
 
         for error in errors or []:
             if isinstance(error, dict) and (extensions := error.get("extensions")):
@@ -228,7 +243,9 @@ def _handle_gql_error(self, exception: TransportQueryError) -> None:
                     raise err_cls(str(exception))
 
         # If no specific error found, raise generic exception
-        raise RivianApiException(f"Error occurred while communicating with Rivian: {exception}")
+        raise RivianApiException(
+            f"Error occurred while communicating with Rivian: {exception}"
+        )
 
     async def create_csrf_token(self) -> None:
         """Create cross-site-request-forgery (csrf) token."""
@@ -274,12 +291,16 @@ async def authenticate(self, username: str, password: str) -> None:
         query = dsl_gql(
             DSLMutation(
                 self._ds.Mutation.login.args(email=username, password=password).select(
-                    DSLInlineFragment().on(self._ds.MobileLoginResponse).select(
+                    DSLInlineFragment()
+                    .on(self._ds.MobileLoginResponse)
+                    .select(
                         self._ds.MobileLoginResponse.accessToken,
                         self._ds.MobileLoginResponse.refreshToken,
                         self._ds.MobileLoginResponse.userSessionToken,
                     ),
-                    DSLInlineFragment().on(self._ds.MobileMFALoginResponse).select(
+                    DSLInlineFragment()
+                    .on(self._ds.MobileMFALoginResponse)
+                    .select(
                         self._ds.MobileMFALoginResponse.otpToken,
                     ),
                 )
@@ -333,7 +354,9 @@ async def validate_otp(self, username: str, otp_code: str) -> None:
                 self._ds.Mutation.loginWithOTP.args(
                     email=username, otpCode=otp_code, otpToken=self._otp_token
                 ).select(
-                    DSLInlineFragment().on(self._ds.MobileLoginResponse).select(
+                    DSLInlineFragment()
+                    .on(self._ds.MobileLoginResponse)
+                    .select(
                         self._ds.MobileLoginResponse.accessToken,
                         self._ds.MobileLoginResponse.refreshToken,
                         self._ds.MobileLoginResponse.userSessionToken,
@@ -662,7 +685,7 @@ async def get_live_charging_session(
     def _validate_vehicle_command(
         self, command: VehicleCommand | str, params: dict[str, Any] | None = None
     ) -> None:
-        """Validate certian vehicle command/param combos."""
+        """Validate certain vehicle command/param combos."""
         if command == VehicleCommand.CHARGING_LIMITS:
             if not (
                 params
@@ -779,6 +802,66 @@ async def send_vehicle_command(
         command_data = result.get("sendVehicleCommand", {})
         return command_data.get("id")
 
+    async def send_location_to_vehicle(
+        self,
+        location_str: str,
+        vehicle_id: str,
+    ) -> ParseAndShareLocationResponse:
+        """Send a location/address to the vehicle's navigation system.
+
+        This mutation does not require phone enrollment or HMAC signing.
+        It works via cloud API only and is a "fire-and-forget" operation.
+        The mutation returns success when the Rivian cloud receives the message,
+        not when the vehicle actually receives it. The vehicle will pick up the
+        destination when it next connects to the cloud.
+
+        Args:
+            location_str: Address string or coordinates
+                         Examples: "123 Main St, Springfield, IL 62701"
+                                  "40.7128,-74.0060" (latitude,longitude)
+            vehicle_id: The vehicle ID to send the location to
+
+        Returns:
+            Response dict with publishResponse.result field (int, where 0 = success)
+
+        Raises:
+            RivianApiException: If the request fails
+            RivianUnauthenticated: If authentication is invalid
+            RivianBadRequestError: If the location string cannot be parsed
+        """
+        client = await self._ensure_client(GRAPHQL_GATEWAY)
+        assert self._ds is not None
+
+        # Build DSL mutation
+        mutation = dsl_gql(
+            DSLMutation(
+                self._ds.Mutation.parseAndShareLocationToVehicle.args(
+                    str=location_str, vehicleId=vehicle_id
+                ).select(
+                    self._ds.ParseAndShareLocationToVehicleResponse.publishResponse.select(
+                        self._ds.PublishResponse.result
+                    )
+                )
+            )
+        )
+
+        # Execute mutation with error handling
+        try:
+            async with async_timeout.timeout(self.request_timeout):
+                result = await client.execute_async(mutation)
+        except TransportQueryError as exception:
+            self._handle_gql_error(exception)
+        except asyncio.TimeoutError as exception:
+            raise RivianApiException(
+                "Timeout occurred while sending location to vehicle."
+            ) from exception
+        except Exception as exception:
+            raise RivianApiException(
+                "Error occurred while sending location to vehicle."
+            ) from exception
+
+        return result.get("parseAndShareLocationToVehicle", {})
+
     async def subscribe_for_vehicle_updates(
         self,
         vehicle_id: str,

src/rivian/schema.py

@@ -1,6 +1,8 @@
 """Minimal GraphQL schema for testing and DSL usage."""
 
 RIVIAN_SCHEMA = """
+scalar GenericScalar
+
 type Query {
   placeholder: String
 }
@@ -12,6 +14,7 @@
   disenrollPhone(attrs: DisenrollPhoneInput!): DisenrollPhoneResponse
   enrollPhone(attrs: EnrollPhoneInput!): EnrollPhoneResponse
   sendVehicleCommand(attrs: SendVehicleCommandInput!): SendVehicleCommandResponse
+  parseAndShareLocationToVehicle(str: String!, vehicleId: String!): ParseAndShareLocationToVehicleResponse
 }
 
 type CreateCSRFTokenResponse {
@@ -58,11 +61,20 @@
   vasPhoneId: String!
   deviceId: String!
   vehicleId: String!
+  params: GenericScalar
 }
 
 type SendVehicleCommandResponse {
   id: String
   command: String
   state: String
 }
+
+type ParseAndShareLocationToVehicleResponse {
+  publishResponse: PublishResponse
+}
+
+type PublishResponse {
+  result: Int
+}
 """

tests/responses.py

@@ -671,6 +671,47 @@
     "data": None,
 }
 
+ENROLL_PHONE_RESPONSE = {
+    "data": {
+        "enrollPhone": {
+            "__typename": "EnrollPhoneResponse",
+            "success": True,
+        }
+    }
+}
+
+DISENROLL_PHONE_RESPONSE = {
+    "data": {
+        "disenrollPhone": {
+            "__typename": "DisenrollPhoneResponse",
+            "success": True,
+        }
+    }
+}
+
+SEND_VEHICLE_COMMAND_RESPONSE = {
+    "data": {
+        "sendVehicleCommand": {
+            "__typename": "SendVehicleCommandResponse",
+            "id": "command-id-123",
+            "command": "WAKE_VEHICLE",
+            "state": "sent",
+        }
+    }
+}
+
+SEND_LOCATION_TO_VEHICLE_RESPONSE = {
+    "data": {
+        "parseAndShareLocationToVehicle": {
+            "__typename": "ParseAndShareLocationToVehicleResponse",
+            "publishResponse": {
+                "__typename": "PublishResponse",
+                "result": 0,
+            },
+        }
+    }
+}
+
 
 def error_response(
     code: str | None = None, reason: str | None = None