fix(websocket): Fix locking issues of esp_websocket_client_send_with_exact_opcode API

Extended examples to cover more cases
Added new config CONFIG_ESP_WS_CLIENT_ENABLE_DYNAMIC_BUFFER for testing

components/esp_websocket_client/examples/target/pytest_websocket.py

@@ -27,10 +27,13 @@ def get_my_ip():
 
 
 class WebsocketTestEcho(WebSocket):
-
     def handleMessage(self):
-        self.sendMessage(self.data)
-        print('\n Server sent: {}\n'.format(self.data))
+        if isinstance(self.data, bytes):
+            print(f'\n Server received binary data: {self.data.hex()}\n')
+            self.sendMessage(self.data, binary=True)
+        else:
+            print(f'\n Server received: {self.data}\n')
+            self.sendMessage(self.data)
 
     def handleConnected(self):
         print('Connection from: {}'.format(self.address))
@@ -86,6 +89,9 @@ def test_examples_protocol_websocket(dut):
       3. send and receive data
     """
 
+    # Test for echo functionality:
+    # Sends a series of simple "hello" messages to the WebSocket server and verifies that each one is echoed back correctly.
+    # This tests the basic responsiveness and correctness of the WebSocket connection.
     def test_echo(dut):
         dut.expect('WEBSOCKET_EVENT_CONNECTED')
         for i in range(0, 5):
@@ -93,12 +99,16 @@ def test_examples_protocol_websocket(dut):
         print('All echos received')
         sys.stdout.flush()
 
+    # Test for clean closure of the WebSocket connection:
+    # Ensures that the WebSocket can correctly receive a close frame and terminate the connection without issues.
     def test_close(dut):
         code = dut.expect(
             re.compile(
                 b'websocket: Received closed message with code=(\\d*)'))[0]
         print('Received close frame with code {}'.format(code))
 
+    # Test for JSON message handling:
+    # Sends a JSON formatted string and verifies that the received message matches the expected JSON structure.
     def test_json(dut, websocket):
         json_string = """
             [
@@ -118,7 +128,7 @@ def test_examples_protocol_websocket(dut):
         match = dut.expect(
             re.compile(b'Json=({[a-zA-Z0-9]*).*}')).group(0).decode()[5:]
         if match == str(data[0]):
-            print('Sent message and received message are equal \n')
+            print('\n Sent message and received message are equal \n')
             sys.stdout.flush()
         else:
             raise ValueError(
@@ -126,6 +136,8 @@ def test_examples_protocol_websocket(dut):
                                  \nreceived: {}\nwith length {}'.format(
                     data[0], len(data[0]), match, len(match)))
 
+    # Test for receiving long messages:
+    # This sends a message with a specified length (2000 characters) to ensure the WebSocket can handle large data payloads. Repeated 3 times for reliability.
     def test_recv_long_msg(dut, websocket, msg_len, repeats):
 
         send_msg = ''.join(
@@ -142,7 +154,7 @@ def test_examples_protocol_websocket(dut):
                 recv_msg += match
 
             if recv_msg == send_msg:
-                print('Sent message and received message are equal \n')
+                print('\n Sent message and received message are equal \n')
                 sys.stdout.flush()
             else:
                 raise ValueError(
@@ -150,9 +162,50 @@ def test_examples_protocol_websocket(dut):
                                 \nreceived: {}\nwith length {}'.format(
                         send_msg, len(send_msg), recv_msg, len(recv_msg)))
 
-    def test_fragmented_msg(dut):
+    # Test for receiving the first fragment of a large message:
+    # Verifies the WebSocket's ability to correctly process the initial segment of a fragmented message.
+    def test_recv_fragmented_msg1(dut):
+        dut.expect('websocket: Total payload length=2000, data_len=1024, current payload offset=0')
+
+    # Test for receiving the second fragment of a large message:
+    # Confirms that the WebSocket can correctly handle and process the subsequent segment of a fragmented message.
+    def test_recv_fragmented_msg2(dut):
+        dut.expect('websocket: Total payload length=2000, data_len=976, current payload offset=1024')
+
+    # Test for receiving fragmented text messages:
+    # Checks if the WebSocket can accurately reconstruct a message sent in several smaller parts.
+    def test_fragmented_txt_msg(dut):
         dut.expect('Received=' + 32 * 'a' + 32 * 'b')
-        print('Fragmented data received')
+        print('\nFragmented data received\n')
+
+    # Extract the hexdump portion of the log line
+    def parse_hexdump(line):
+        match = re.search(r'\(.*\) Received binary data: ([0-9A-Fa-f ]+)', line)
+        if match:
+            hexdump = match.group(1).strip().replace(' ', '')
+            # Convert the hexdump string to a bytearray
+            return bytearray.fromhex(hexdump)
+        return bytearray()
+
+    # Capture the binary log output from the DUT
+    def test_fragmented_binary_msg(dut):
+        match = dut.expect(r'\(.*\) Received binary data: .*')
+        if match:
+            line = match.group(0).strip()
+            if isinstance(line, bytes):
+                line = line.decode('utf-8')
+
+            # Parse the hexdump from the log line
+            received_data = parse_hexdump(line)
+
+            # Create the expected bytearray with the specified pattern
+            expected_data = bytearray([0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
+
+            # Validate the received data
+            assert received_data == expected_data, f'Received data does not match expected data. Received: {received_data}, Expected: {expected_data}'
+            print('\nFragmented data received\n')
+        else:
+            assert False, 'Log line with binary data not found'
 
     # Starting of the test
     try:
@@ -184,10 +237,12 @@ def test_examples_protocol_websocket(dut):
             dut.expect('Please enter uri of websocket endpoint', timeout=30)
             dut.write(uri)
             test_echo(dut)
-            # Message length should exceed DUT's buffer size to test fragmentation, default is 1024 byte
             test_recv_long_msg(dut, ws, 2000, 3)
             test_json(dut, ws)
-            test_fragmented_msg(dut)
+            test_fragmented_txt_msg(dut)
+            test_fragmented_binary_msg(dut)
+            test_recv_fragmented_msg1(dut)
+            test_recv_fragmented_msg2(dut)
             test_close(dut)
     else:
         print('DUT connecting to {}'.format(uri))