| # | |
| # Copyright (c) 2026 Project CHIP Authors | |
| # All rights reserved. | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # 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. | |
| # See https://github.com/project-chip/connectedhomeip/blob/master/docs/testing/python.md#defining-the-ci-test-arguments | |
| # for details about the block below. | |
| # | |
| # === BEGIN CI TEST ARGUMENTS === | |
| # test-runner-runs: | |
| # run1: | |
| # app: ${CAMERA_APP} | |
| # app-args: --discriminator 1234 --KVS kvs1 --trace-to json:${TRACE_APP}.json | |
| # script-args: > | |
| # --PICS src/app/tests/suites/certification/ci-pics-values | |
| # --storage-path admin_storage.json | |
| # --commissioning-method on-network | |
| # --discriminator 1234 | |
| # --passcode 20202021 | |
| # --trace-to json:${TRACE_TEST_JSON}.json | |
| # --trace-to perfetto:${TRACE_TEST_PERFETTO}.perfetto | |
| # factory-reset: true | |
| # quiet: true | |
| # === END CI TEST ARGUMENTS === | |
| # | |
| """Checks that WebRTCPeerConnection.send_command() forwards every SolicitOffer / ProvideOffer field to the camera. | |
| send_command() goes through the C++ WebRTCTransportProviderClient, which re-encodes the command instead of sending | |
| the caller's TLV as-is. These tests send the stream lists, SFrameConfig, ICEServers and ICETransportPolicy, which the | |
| plain send_single_cmd() path already covers in TC_WEBRTCP_2_*. | |
| """ | |
| import logging | |
| from mobly import asserts | |
| from TC_WEBRTCPTestBase import WEBRTCPTestBase | |
| from matter.ChipDeviceCtrl import TransportPayloadCapability | |
| from matter.clusters import Objects, WebRTCTransportProvider | |
| from matter.clusters.Types import NullValue | |
| from matter.interaction_model import InteractionModelError, Status | |
| from matter.testing.decorators import async_test_body | |
| from matter.testing.matter_testing import MatterTestCommissionedDevice | |
| from matter.testing.runner import default_matter_test_main | |
| from matter.webrtc import LibdatachannelPeerConnection, WebRTCManager | |
| log = logging.getLogger(__name__) | |
| class TestWebRTCProviderClientStreamFields(MatterTestCommissionedDevice, WEBRTCPTestBase): | |
| @property | |
| def default_timeout(self) -> int: | |
| return 4 * 60 | |
| @property | |
| def default_endpoint(self) -> int: | |
| return 1 | |
| def create_peer(self, webrtc_manager: WebRTCManager) -> LibdatachannelPeerConnection: | |
| return webrtc_manager.create_peer( | |
| node_id=self.dut_node_id, fabric_index=self.default_controller.GetFabricIndexInternal(), endpoint=self.get_endpoint() | |
| ) | |
| async def allocate_streams(self) -> tuple[int, int]: | |
| audio_stream_id = await self.allocate_one_audio_stream() | |
| video_stream_id = await self.allocate_one_video_stream() | |
| await self.validate_allocated_audio_stream(audio_stream_id) | |
| await self.validate_allocated_video_stream(video_stream_id) | |
| return video_stream_id, audio_stream_id | |
| async def assert_session_streams(self, session_id: int, video_stream_id: int, audio_stream_id: int): | |
| current_sessions = await self.read_single_attribute_check_success( | |
| cluster=WebRTCTransportProvider, | |
| attribute=WebRTCTransportProvider.Attributes.CurrentSessions, | |
| endpoint=self.get_endpoint(), | |
| ) | |
| session = next((s for s in current_sessions if s.id == session_id), None) | |
| asserts.assert_is_not_none(session, f"Session {session_id} not found in CurrentSessions") | |
| asserts.assert_equal(session.videoStreamID, video_stream_id, "Session uses the wrong video stream") | |
| asserts.assert_equal(session.audioStreamID, audio_stream_id, "Session uses the wrong audio stream") | |
| async def send_ice_candidates_and_wait_for_session(self, webrtc_peer: LibdatachannelPeerConnection, session_id: int): | |
| local_candidates = await webrtc_peer.get_local_ice_candidates() | |
| await self.send_single_cmd( | |
| cmd=WebRTCTransportProvider.Commands.ProvideICECandidates( | |
| webRTCSessionID=session_id, | |
| ICECandidates=[Objects.Globals.Structs.ICECandidateStruct(candidate=cand.candidate) for cand in local_candidates], | |
| ), | |
| endpoint=self.get_endpoint(), | |
| payloadCapability=TransportPayloadCapability.LARGE_PAYLOAD, | |
| ) | |
| asserts.assert_true(await webrtc_peer.check_for_session_establishment(), "Failed to establish WebRTC session") | |
| async def end_session(self, session_id: int): | |
| await self.send_single_cmd( | |
| cmd=WebRTCTransportProvider.Commands.EndSession( | |
| webRTCSessionID=session_id, reason=Objects.Globals.Enums.WebRTCEndReasonEnum.kUserHangup | |
| ), | |
| endpoint=self.get_endpoint(), | |
| payloadCapability=TransportPayloadCapability.LARGE_PAYLOAD, | |
| ) | |
| async def assert_constraint_error(self, webrtc_peer: LibdatachannelPeerConnection, cmd, field: str): | |
| """Sends cmd through webrtc_peer and expects the provider to reject the value in field with CONSTRAINT_ERROR. | |
| The rejection shows that field reached the provider: if the client dropped it, the command would succeed. | |
| """ | |
| try: | |
| await webrtc_peer.send_command(cmd=cmd, endpoint=self.get_endpoint(), | |
| payloadCapability=TransportPayloadCapability.LARGE_PAYLOAD) | |
| asserts.fail(f"{type(cmd).__name__} with an invalid {field} succeeded; {field} was not sent") | |
| except InteractionModelError as e: | |
| asserts.assert_equal(e.status, Status.ConstraintError, | |
| f"Expected CONSTRAINT_ERROR for an invalid {field} in {type(cmd).__name__}") | |
| @async_test_body | |
| async def test_constraint_checked_fields_are_forwarded(self): | |
| video_stream_id, _ = await self.allocate_streams() | |
| webrtc_manager = WebRTCManager(event_loop=self.event_loop) | |
| webrtc_peer = self.create_peer(webrtc_manager) | |
| webrtc_peer.create_offer() | |
| offer = await webrtc_peer.get_local_offer() | |
| # Each value violates a provider constraint: a Kid shorter than 2 bytes, an ICE server URL longer than | |
| # 2000 characters (as the second URL, so the whole URL list must be forwarded), and an ICETransportPolicy | |
| # longer than 16 characters. | |
| invalid_fields = { | |
| "SFrameConfig": WebRTCTransportProvider.Structs.SFrameStruct(cipherSuite=0x0002, baseKey=b"\x00" * 32, kid=b"\x01"), | |
| "ICEServers": [Objects.Globals.Structs.ICEServerStruct(URLs=["stun:stun.example.com", "stun:" + "a" * 2001])], | |
| "ICETransportPolicy": "a" * 17, | |
| } | |
| for field, value in invalid_fields.items(): | |
| await self.assert_constraint_error(webrtc_peer, WebRTCTransportProvider.Commands.SolicitOffer( | |
| streamUsage=Objects.Globals.Enums.StreamUsageEnum.kLiveView, | |
| originatingEndpointID=1, | |
| videoStreamID=video_stream_id, | |
| **{field: value}, | |
| ), field) | |
| await self.assert_constraint_error(webrtc_peer, WebRTCTransportProvider.Commands.ProvideOffer( | |
| webRTCSessionID=NullValue, | |
| sdp=offer, | |
| streamUsage=Objects.Globals.Enums.StreamUsageEnum.kLiveView, | |
| originatingEndpointID=1, | |
| videoStreamID=video_stream_id, | |
| **{field: value}, | |
| ), field) | |
| await webrtc_manager.close_all() | |
| @async_test_body | |
| async def test_solicit_offer_with_stream_lists(self): | |
| video_stream_id, audio_stream_id = await self.allocate_streams() | |
| webrtc_manager = WebRTCManager(event_loop=self.event_loop) | |
| webrtc_peer = self.create_peer(webrtc_manager) | |
| solicit_offer_response: WebRTCTransportProvider.Commands.SolicitOfferResponse = await webrtc_peer.send_command( | |
| cmd=WebRTCTransportProvider.Commands.SolicitOffer( | |
| streamUsage=Objects.Globals.Enums.StreamUsageEnum.kLiveView, | |
| originatingEndpointID=1, | |
| videoStreams=[video_stream_id], | |
| audioStreams=[audio_stream_id], | |
| ), | |
| endpoint=self.get_endpoint(), | |
| payloadCapability=TransportPayloadCapability.LARGE_PAYLOAD, | |
| ) | |
| session_id = solicit_offer_response.webRTCSessionID | |
| asserts.assert_false(solicit_offer_response.deferredOffer, "Expected deferredOffer = False") | |
| webrtc_manager.session_id_created(session_id, self.dut_node_id) | |
| offer_session_id, remote_offer_sdp = await webrtc_peer.get_remote_offer(timeout_s=5) | |
| asserts.assert_equal(offer_session_id, session_id, "Offer received with the wrong session ID") | |
| webrtc_peer.set_remote_offer(remote_offer_sdp) | |
| await self.assert_session_streams(session_id, video_stream_id, audio_stream_id) | |
| local_answer = await webrtc_peer.get_local_answer() | |
| await self.send_single_cmd( | |
| cmd=WebRTCTransportProvider.Commands.ProvideAnswer(webRTCSessionID=session_id, sdp=local_answer), | |
| endpoint=self.get_endpoint(), | |
| payloadCapability=TransportPayloadCapability.LARGE_PAYLOAD, | |
| ) | |
| await self.send_ice_candidates_and_wait_for_session(webrtc_peer, session_id) | |
| await self.end_session(session_id) | |
| await webrtc_manager.close_all() | |
| @async_test_body | |
| async def test_provide_offer_with_stream_lists(self): | |
| video_stream_id, audio_stream_id = await self.allocate_streams() | |
| webrtc_manager = WebRTCManager(event_loop=self.event_loop) | |
| webrtc_peer = self.create_peer(webrtc_manager) | |
| webrtc_peer.create_offer() | |
| local_offer = await webrtc_peer.get_local_offer() | |
| provide_offer_response: WebRTCTransportProvider.Commands.ProvideOfferResponse = await webrtc_peer.send_command( | |
| cmd=WebRTCTransportProvider.Commands.ProvideOffer( | |
| webRTCSessionID=NullValue, | |
| sdp=local_offer, | |
| streamUsage=Objects.Globals.Enums.StreamUsageEnum.kLiveView, | |
| originatingEndpointID=1, | |
| videoStreams=[video_stream_id], | |
| audioStreams=[audio_stream_id], | |
| ), | |
| endpoint=self.get_endpoint(), | |
| payloadCapability=TransportPayloadCapability.LARGE_PAYLOAD, | |
| ) | |
| session_id = provide_offer_response.webRTCSessionID | |
| webrtc_manager.session_id_created(session_id, self.dut_node_id) | |
| answer_session_id, answer = await webrtc_peer.get_remote_answer() | |
| asserts.assert_equal(answer_session_id, session_id, "Answer received with the wrong session ID") | |
| webrtc_peer.set_remote_answer(answer) | |
| await self.assert_session_streams(session_id, video_stream_id, audio_stream_id) | |
| await self.send_ice_candidates_and_wait_for_session(webrtc_peer, session_id) | |
| await self.end_session(session_id) | |
| await webrtc_manager.close_all() | |
| if __name__ == "__main__": | |
| default_matter_test_main() |