KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use handle_rpc_request method in autotest

Best Python code snippet using autotest_python

test_server.py

Source:test_server.py

...569                    procedure=mock_procedure,570                    args=fake_args,571                    kwargs=fake_kwargs,572                )573        def describe_handle_rpc_request():574            def reject_if_term_too_low(server, mock_procedure, message_id, fake_args, fake_kwargs):575                server.current_term = 1576                mock_procedure.return_value = "this shouldn't be returned"577                mock_procedure.assert_not_called()578                server.rpc.assert_not_called()579                server.handle_rpc_request(580                    message_id=message_id,581                    origin=server.peers[0],582                    term=0,583                    procedure=mock_procedure,584                    args=fake_args,585                    kwargs=fake_kwargs,586                )587                mock_procedure.assert_not_called()588                server.rpc.assert_called_once_with(589                    server.peers[0],590                    {591                        "method": "response",592                        "message_id": message_id,593                        "term": server.current_term,594                        "response": False,595                    }596                )597            def call_specified_procedure(server, message_id, mock_procedure, fake_args, fake_kwargs):598                if server.role == Role.LEADER:599                    pytest.skip()600                server.current_term = 1601                server.procedures_by_name = {602                    "mock_procedure": mock_procedure,603                }604                mock_procedure.assert_not_called()605                server.handle_rpc_message(606                    origin=server.peers[0],607                    message={608                        "method": "request",609                        "message_id": message_id,610                        "term": 1,611                        "procedure": "mock_procedure",612                        "args": fake_args,613                        "kwargs": fake_kwargs,614                    }615                )616                mock_procedure.assert_called_once_with(*fake_args, **fake_kwargs)617                assert server.current_term == 1618            def procedure_map_correct_for_append_entries(server, mocker, message_id):619                if server.role == Role.LEADER:620                    pytest.skip()621                server.rpc.assert_not_called()622                server.append_entries = mocker.MagicMock(wraps=server.append_entries)623                server.procedures_by_name["append_entries"] = server.append_entries # update the reference624                server.handle_rpc_message(625                    origin=server.peers[0],626                    message={627                        "method": "request",628                        "message_id": message_id,629                        "term": 0,630                        "procedure": "append_entries",631                        "args": [],632                        "kwargs": {633                            "leader_id": server.peers[0],634                            "prev_log_index": None,635                            "prev_log_term": None,636                            "entries": [],637                            "leader_commit": None,638                        },639                    }640                )641                server.append_entries.assert_called_once_with(642                    leader_id=server.peers[0],643                    prev_log_index=None,644                    prev_log_term=None,645                    entries=[],646                    leader_commit=None,647                )648                server.rpc.assert_called_once_with(649                    server.peers[0],650                    {651                        "method": "response",652                        "message_id": message_id,653                        "term": 0,654                        "response": True,655                    }656                )657            def procedure_map_correct_for_request_vote(server, mocker, message_id):658                if server.role == Role.LEADER:659                    pytest.skip()660                server.rpc.assert_not_called()661                server.request_vote = mocker.MagicMock(wraps=server.request_vote)662                server.procedures_by_name["request_vote"] = server.request_vote # update the reference663                server.handle_rpc_message(664                    origin=server.peers[0],665                    message={666                        "method": "request",667                        "message_id": message_id,668                        "term": 0,669                        "procedure": "request_vote",670                        "args": [],671                        "kwargs": {672                            "candidate_id": server.peers[0],673                            "last_log_index": 1,674                            "last_log_term": 1,675                        },676                    }677                )678                server.request_vote.assert_called_once_with(679                    candidate_id=server.peers[0],680                    last_log_index=1,681                    last_log_term=1,682                )683                server.rpc.assert_called_once_with(684                    server.peers[0],685                    {686                        "method": "response",687                        "message_id": message_id,688                        "term": 0,689                        "response": True,690                    }691                )692        def describe_handle_rpc_response():693            def update_term(server, mocker):694                server.current_term = 0695                server.handle_rpc_response(696                    original_request=mocker.MagicMock(),697                    term=1,698                    response=mocker.MagicMock(),699                )700                assert server.current_term == 1701            def dont_downdate_term(server, mocker):702                server.current_term = 1703                server.handle_rpc_response(704                    original_request=mocker.MagicMock(),705                    term=0,706                    response=mocker.MagicMock(),707                )708                assert server.current_term == 1709        710        def describe_send_rpc_request():711            @pytest.fixture712            def mock_uuid4(mocker):713                return mocker.patch("uuid.uuid4")714            def uses_rpc(server, mock_uuid4, fake_args, fake_kwargs):715                mock_uuid4.return_value = "test uuid"716                server.rpc.assert_not_called()717                mock_uuid4.assert_not_called()718                server.send_rpc_request(719                    recipient=server.peers[0],720                    procedure="test procedure",721                    args=fake_args,722                    kwargs=fake_kwargs,723                )724                server.rpc.assert_called_once_with(725                    server.peers[0],726                    {727                        "method": "request",728                        "message_id": "test uuid",729                        "term": server.current_term,730                        "procedure": "test procedure",731                        "args": fake_args,732                        "kwargs": fake_kwargs,733                    }734                )735                mock_uuid4.assert_called_once_with()736            def remember_sent_message(server, mock_uuid4, fake_args, fake_kwargs, now):737                mock_uuid4.return_value = "test uuid"738                server.message_timeout_ms = 2500739                assert "test uuid" not in server.awaiting_reply740                server.send_rpc_request(741                    recipient=server.peers[0],742                    procedure="test procedure",743                    args=fake_args,744                    kwargs=fake_kwargs,745                )746                assert server.awaiting_reply["test uuid"] == {747                    "response_deadline": now + 2.5,748                    "request": {749                        "recipient": server.peers[0],750                        "procedure": "test procedure",751                        "args": fake_args,752                        "kwargs": fake_kwargs,753                    },754                }755                server.rng.assert_not_called() # unlike with other timeouts756def a_non_follower_server():757    def describe_tick():758        def describe_retry_requests():759            def retry_request(server, message_id, fake_args, fake_kwargs, now):760                server.rpc.assert_not_called()761                server.awaiting_reply[message_id] = {762                    "response_deadline": now - 0.0001,763                    "request": {764                        "recipient": server.peers[0],765                        "procedure": "test procedure",766                        "args": fake_args,767                        "kwargs": fake_kwargs,768                    },769                }                770                server.tick()771                server.rpc.assert_called_once_with(772                    server.peers[0],773                    {774                        "method": "request",775                        "message_id": message_id,776                        "term": server.current_term,777                        "procedure": "test procedure",778                        "args": fake_args,779                        "kwargs": fake_kwargs,780                    }781                )782            def update_timestamp_on_retried_request(server, message_id, fake_args, fake_kwargs, now):783                server.message_timeout_ms = 50784                server.awaiting_reply[message_id] = {785                    "response_deadline": now - 0.0001,786                    "request": {787                        "recipient": server.peers[0],788                        "procedure": "test procedure",789                        "args": fake_args,790                        "kwargs": fake_kwargs,791                    },792                }                793                server.tick()794                795                assert server.awaiting_reply[message_id]["response_deadline"] == now + 0.05796            def retry_multiple_requests(server, fake_args, fake_kwargs, now):797                server.message_timeout_ms = 1000798                message_ids = [uuid.uuid4() for _ in range(3)]799                server.awaiting_reply = {800                    mid: {801                        "response_deadline": now - 0.1,802                        "request": {803                            "recipient": server.peers[0],804                            "procedure": "test procedure",805                            "args": fake_args,806                            "kwargs": fake_kwargs,807                        },808                    }809                    for mid in message_ids810                }811                server.rpc.assert_not_called()812                server.tick()813                assert len(server.rpc.call_args_list) == 3814            def dont_retry_request_that_hasnt_timed_out(server, message_id, fake_args, fake_kwargs, now):815                server.rpc.assert_not_called()816                server.awaiting_reply[message_id] = {817                    "response_deadline": now + 0.0001,818                    "request": {819                        "recipient": server.peers[0],820                        "procedure": "test procedure",821                        "args": fake_args,822                        "kwargs": fake_kwargs,823                    },824                }                825                server.tick()826                server.rpc.assert_not_called()827                assert server.awaiting_reply[message_id]["response_deadline"] == now + 0.0001828    def describe_handle_rpc_message():829        def become_follower_when_term_behind(server, message_id):830            server.current_term = 0831            assert server.role != Role.FOLLOWER832            server.handle_rpc_message(833                origin=server.peers[0],834                message={835                    "method": "response",836                    "message_id": message_id,837                    "term": 3,838                    "response": False,839                }840            )841            assert server.role == Role.FOLLOWER842        def dont_become_follower_when_not_behind(server, message_id):843            server.current_term = 0844            assert server.role != Role.FOLLOWER845            server.handle_rpc_message(846                origin=server.peers[0],847                message={848                    "method": "response",849                    "message_id": message_id,850                    "term": 0,851                    "response": False,852                }853            )854            assert server.role != Role.FOLLOWER        855        def discard_outbox_if_became_follower(server, message_id, fake_args, fake_kwargs):856            server.current_term = 0857            message_ids = [uuid.uuid4() for _ in range(3)]858            server.awaiting_reply = {859                mid: {860                    "response_deadline": 12345,861                    "request": {862                        "recipient": server.peers[0],863                        "procedure": "test procedure",864                        "args": fake_args,865                        "kwargs": fake_kwargs,866                    },867                }868                for mid in message_ids869            }870            server.handle_rpc_message(871                origin=server.peers[0],872                message={873                    "method": "response",874                    "message_id": message_id,875                    "term": 3,876                    "response": False,877                }878            )879            assert len(server.awaiting_reply) == 0880        def handle_response_message(server, mocker, message_id, generic_request_message):881            server.handle_rpc_request = mocker.MagicMock(wraps=server.handle_rpc_request)882            server.handle_rpc_response = mocker.MagicMock(wraps=server.handle_rpc_response)883            server.handle_rpc_response.assert_not_called()884            server.handle_rpc_request.assert_not_called()885            server.awaiting_reply[message_id] = {"timeout": 999999, "request": generic_request_message}886            assert message_id in server.awaiting_reply887            server.handle_rpc_message(888                origin=server.peers[0],889                message={890                    "method": "response",891                    "message_id": message_id,892                    "term": 0,893                    "response": False,894                }895            )896            server.handle_rpc_request.assert_not_called()897            server.handle_rpc_response.assert_called_once_with(898                original_request=generic_request_message,899                term=0,900                response=False,901            )902        def remove_handled_response_from_awaiting_reply(server, mocker, message_id, generic_request_message):903            server.handle_rpc_response = mocker.MagicMock(wraps=server.handle_rpc_response)904            server.awaiting_reply[message_id] = {"timeout": 999999, "request": generic_request_message}905            assert message_id in server.awaiting_reply906            server.handle_rpc_message(907                origin=server.peers[0],908                message={909                    "method": "response",910                    "message_id": message_id,911                    "term": 0,912                    "response": False,913                }914            )915            assert message_id not in server.awaiting_reply916        def discard_responses_if_not_awaiting_reply(server, mocker, message_id):917            server.handle_rpc_request = mocker.MagicMock(wraps=server.handle_rpc_request)918            server.handle_rpc_response = mocker.MagicMock(wraps=server.handle_rpc_response)919            server.handle_rpc_response.assert_not_called()920            server.handle_rpc_request.assert_not_called()921            assert message_id not in server.awaiting_reply922            server.handle_rpc_message(923                origin=server.peers[0],924                message={925                    "method": "response",926                    "message_id": message_id,927                    "term": 0,928                    "response": False,929                }930            )931            server.handle_rpc_request.assert_not_called()932            server.handle_rpc_response.assert_not_called()933@behaves_like(a_server)934def describe_follower():935    @pytest.fixture936    def server(follower):937        return follower938        939    def describe_tick():940        def describe_check_heartbeat():941            def convert_to_candidate_on_timeout(server, now):942                server.heartbeat_deadline = now - 0.01943                assert server.role == Role.FOLLOWER944                server.tick()945                assert server.role == Role.CANDIDATE946                assert server.heartbeat_deadline is None947                assert server.election_deadline > now948            def do_not_convert_to_candidate_before_timeout(server, now):949                server.heartbeat_deadline = now + 0.01950                assert server.role == Role.FOLLOWER951                server.tick()952                assert server.role == Role.FOLLOWER953                assert server.heartbeat_deadline == now + 0.01954                assert server.election_deadline is None955    def describe_handle_rpc_message():956        def handle_rpc_request(server, mocker, message_id, mock_procedure, fake_args, fake_kwargs):957            server.handle_rpc_request = mocker.MagicMock()958            server.procedures_by_name = {959                "mock_procedure": mock_procedure,960            }961            server.handle_rpc_request.assert_not_called()962            server.handle_rpc_message(963                origin=server.peers[0],964                message={965                    "method": "request",966                    "message_id": message_id,967                    "term": 0,968                    "procedure": "mock_procedure",969                    "args": fake_args,970                    "kwargs": fake_kwargs,971                }              972            )973            server.handle_rpc_request.assert_called_once_with(974                message_id=message_id,975                origin=server.peers[0],976                term=0,977                procedure=mock_procedure,978                args=fake_args,979                kwargs=fake_kwargs,980            )981        def discard_responses(server, mocker, message_id):982            # Somewhat redundant, because a follower will not be awaiting any responses983            server.handle_rpc_response = mocker.MagicMock()984            server.awaiting_reply[message_id] = {"timeout": 999999, "request": generic_request_message}985            server.handle_rpc_response.assert_not_called()986            server.handle_rpc_message(987                origin=server.peers[0],988                message={989                    "method": "response",990                    "message_id": message_id,991                    "term": 3,992                    "response": False,993                }994            )995            996            server.handle_rpc_response.assert_not_called()997    def describe_handle_client_request():998        def when_coming_from_client():999            pass1000        def when_forwarded():1001            pass1002@behaves_like(a_server)1003@behaves_like(a_non_follower_server)1004def describe_candidate():1005    @pytest.fixture1006    def server(follower, now):1007        follower.role = Role.CANDIDATE1008        follower.leader_id = None1009        follower.election_deadline = now + 10001010        return follower1011    def describe_tick():1012        def describe_election_timeout():1013            def on_timeout_start_new_election(server, mocker, initial_log, now):1014                server.election_timeout_range_ms = (1000, 2000)1015                server.rng.return_value = 0.251016                server.send_rpc_request = mocker.MagicMock()1017                server.commit_index = 11018                server.votes = set([server.peers[0]])1019                server.election_deadline = now - 0.011020                assert server.current_term == 01021                server.send_rpc_request.assert_not_called()1022                server.tick()1023                assert server.election_deadline == now + 1.251024                assert server.current_term == 11025                assert len(server.votes) == 0 # Actually 1, from self-vote1026                server.send_rpc_request.assert_has_calls(1027                    [1028                        mocker.call(1029                            recipient=peer_id,1030                            procedure="request_vote",1031                            args=[],1032                            kwargs={1033                                "last_log_index": 2, # Not last committed1034                                "last_log_term": 0,1035                            }1036                        )1037                        for peer_id in server.peers1038                    ],1039                    any_order=True,1040                )1041            def on_timeout_start_new_election_with_empty_log(server, mocker, now):1042                server.election_timeout_range_ms = (1000, 2000)1043                server.rng.return_value = 0.251044                server.send_rpc_request = mocker.MagicMock()1045                server.election_deadline = now - 0.011046                assert server.current_term == 01047                server.send_rpc_request.assert_not_called()1048                assert len(server.log) == 01049                server.tick()1050                server.send_rpc_request.assert_has_calls(1051                    [1052                        mocker.call(1053                            recipient=peer_id,1054                            procedure="request_vote",1055                            args=[],1056                            kwargs={1057                                "last_log_index": None,1058                                "last_log_term": None,1059                            }1060                        )1061                        for peer_id in server.peers1062                    ],1063                    any_order=True,1064                )1065            def before_timeout_dont_start_new_election(server, mocker, now):1066                server.election_timeout_range_ms = (1000, 2000)1067                server.rng.return_value = 0.251068                server.send_rpc_request = mocker.MagicMock()1069                server.commit_index = None1070                server.votes = set([server.peers[0]])1071                server.election_deadline = now + 0.011072                assert server.current_term == 01073                server.send_rpc_request.assert_not_called()1074                server.tick()1075                assert server.election_deadline == now + 0.011076                assert server.current_term == 01077                assert len(server.votes) == 11078                server.send_rpc_request.assert_not_called()1079    def describe_append_entries():1080        def describe_handle_append_entries():1081            def discard_if_term_too_low(server, message_id):1082                server.current_term = 11083                assert server.role == Role.CANDIDATE1084                server.handle_rpc_request(1085                    message_id=message_id,1086                    origin=server.peers[0],1087                    term=0,1088                    procedure=server.append_entries,1089                    args=[],1090                    kwargs={1091                        "leader_id": server.peers[0],1092                        "prev_log_index": None,1093                        "prev_log_term": None,1094                        "entries": [],1095                        "leader_commit": None,1096                    }  1097                )1098                server.current_term = 11099                assert server.role == Role.CANDIDATE1100                assert server.heartbeat_deadline is None1101                assert server.election_deadline is not None1102            def if_equal_term_become_follower(server, message_id):1103                server.current_term = 11104                assert server.role == Role.CANDIDATE1105                server.handle_rpc_request(1106                    message_id=message_id,1107                    origin=server.peers[0],1108                    term=1,1109                    procedure=server.append_entries,1110                    args=[],1111                    kwargs={1112                        "leader_id": server.peers[0],1113                        "prev_log_index": None,1114                        "prev_log_term": None,1115                        "entries": [],1116                        "leader_commit": None,1117                    }  1118                )1119                server.current_term = 11120                assert server.role == Role.FOLLOWER1121                assert server.heartbeat_deadline is not None1122                assert server.election_deadline is None1123    def describe_handle_rpc_response():1124        def describe_handle_request_vote_response():1125            @pytest.fixture1126            def request_for_vote(server, now, message_id, fake_args, fake_kwargs):1127                request = {1128                    "recipient": server.peers[0],1129                    "procedure": "request_vote",1130                    "args": fake_args,1131                    "kwargs": fake_kwargs,1132                }1133                server.awaiting_reply[message_id] = {1134                    "response_deadline": now + 10000,1135                    "request": request1136                }1137                return request1138            def gain_vote_on_success(server, request_for_vote):1139                assert len(server.votes) == 01140                server.handle_rpc_response(1141                    original_request=request_for_vote,1142                    term=server.current_term,1143                    response=True,1144                )1145                assert len(server.votes) == 11146                assert server.peers[0] in server.votes1147            def dont_gain_vote_on_failure(server, request_for_vote):1148                assert len(server.votes) == 01149                server.handle_rpc_response(1150                    original_request=request_for_vote,1151                    term=server.current_term,1152                    response=False,1153                )1154                assert len(server.votes) == 01155            def describe_win():1156                def become_leader(server, request_for_vote, generic_request_message, now, initial_log):1157                    server.votes.add(server.peers[3])1158                    assert len(server.votes) + 1 < (len(server.peers) + 1) / 21159                    assert len(server.votes) + 2 > (len(server.peers) + 1) / 21160                    assert server.role == Role.CANDIDATE1161                    assert server.next_index == {peer_id: None for peer_id in server.peers}1162                    assert server.match_index == {peer_id: None for peer_id in server.peers}1163                    server.awaiting_reply[uuid.uuid4()] = {1164                        "response_deadline": now + 10000,1165                        "request": generic_request_message,1166                    }1167                    assert len(server.awaiting_reply) == 21168                    server.handle_rpc_response(1169                        original_request=request_for_vote,1170                        term=server.current_term,1171                        response=True,1172                    )1173                    assert server.role == Role.LEADER1174                    assert len(server.votes) == 01175                    assert server.election_deadline is None1176                    assert len(server.awaiting_reply) == len(server.peers)1177                    assert server.next_index == {peer_id: len(server.log) for peer_id in server.peers}1178                    assert server.match_index == {peer_id: 0 for peer_id in server.peers}1179                def send_heartbeat(server, request_for_vote, generic_request_message, now, mocker):1180                    server.votes.add(server.peers[3])1181                    server.awaiting_reply[uuid.uuid4()] = {1182                        "response_deadline": now + 10000,1183                        "request": generic_request_message,1184                    }1185                    server.send_rpc_request = mocker.MagicMock()1186                    server.send_rpc_request.assert_not_called()1187                    server.handle_rpc_response(1188                        original_request=request_for_vote,1189                        term=server.current_term,1190                        response=True,1191                    )1192                    server.send_rpc_request.assert_has_calls(1193                        [1194                            mocker.call(1195                                recipient=peer_id,1196                                procedure="append_entries",1197                                args=[],1198                                kwargs={1199                                    "leader_id": server.id,1200                                    "prev_log_index": None,1201                                    "prev_log_term": None,1202                                    "entries": [],1203                                    "leader_commit": None,1204                                }1205                            )1206                            for peer_id in server.peers1207                        ],1208                        any_order=True,1209                    )1210    def describe_handle_client_request():1211        def when_coming_from_client():1212            pass1213        def when_forwarded():1214            pass1215@behaves_like(a_server)1216@behaves_like(a_non_follower_server)1217def describe_leader():1218    @pytest.fixture1219    def server(follower):1220        follower.role = Role.LEADER1221        follower.leader_id = None1222        follower.next_index = {peer_id: len(follower.log) for peer_id in follower.peers}1223        follower.match_index = {peer_id: 0 for peer_id in follower.peers}1224        return follower1225    def describe_tick():1226        def update_followers_that_are_behind(server, initial_log, mocker):1227            server.next_index = {1228                server.peers[i]: i1229                for i in range(len(server.peers))1230            }1231            server.commit_index = 11232            server.send_rpc_request = mocker.MagicMock()1233            server.send_rpc_request.assert_not_called()1234            server.tick()1235            assert len(server.send_rpc_request.call_args_list) == 31236            server.send_rpc_request.assert_has_calls(1237                [1238                    mocker.call(1239                        recipient=server.peers[0],1240                        procedure="append_entries",1241                        args=[],1242                        kwargs={1243                            "leader_id": server.id,1244                            "prev_log_index": None,1245                            "prev_log_term": None,1246                            "entries": server.log,1247                            "leader_commit": 1,1248                        },1249                    ),1250                    mocker.call(1251                        recipient=server.peers[1],1252                        procedure="append_entries",1253                        args=[],1254                        kwargs={1255                            "leader_id": server.id,1256                            "prev_log_index": 0,1257                            "prev_log_term": server.log[0][0],1258                            "entries": server.log[1:],1259                            "leader_commit": 1,1260                        },1261                    ),1262                    mocker.call(1263                        recipient=server.peers[2],1264                        procedure="append_entries",1265                        args=[],1266                        kwargs={1267                            "leader_id": server.id,1268                            "prev_log_index": 1,1269                            "prev_log_term": server.log[1][0],1270                            "entries": server.log[2:],1271                            "leader_commit": 1,1272                        },1273                    ),1274                ],1275                any_order=True,1276            )1277    def dont_call_any_procedures_for_handle_rpc_request(1278        server, message_id, mock_procedure, fake_args, fake_kwargs,1279    ):1280        mock_procedure.assert_not_called()1281        server.rpc.assert_not_called()        1282        server.handle_rpc_request(1283            message_id=message_id,1284            origin=server.peers[0],1285            term=0,1286            procedure=mock_procedure,1287            args=fake_args,1288            kwargs=fake_kwargs,1289        )1290        mock_procedure.assert_not_called()1291        server.rpc.assert_called_once_with(1292            server.peers[0],1293            {1294                "method": "response",1295                "message_id": message_id,1296                "term": server.current_term,...

client.py

Source:client.py

...42        :return:43        """44        req = WXServiceRequest(**req_param)45        return new_get_user_info_response(req)46async def handle_rpc_request(req: Request):47    """ RPC Method Handler48    :param req:49    :return:50    """51    b = req.json52    if is_json_rpc_request(req.method, b):53        _b_get = b.get54        method = _b_get("method")55        params = _b_get("params")56        if not all([method, params]):57            return fine(msg="invalid request")58        handler = _FansJSONRPCHandler(req.url)59        if not hasattr(handler, method):60            return fine(msg="not found")...

freemem.py

Source:freemem.py

...13        telemetry_interval = int(value['telemetryInterval'])14    elif 'shared' in value and 'telemetryInterval' in value['shared']:15        telemetry_interval = int(value['shared']['telemetryInterval'])16# this callback handles RPC requests from server17def handle_rpc_request(request_id, method, params):18    print('Request ID {req}: {method}({params})'.format(req=request_id,19                                                        method=method,20                                                        params=params))21    if method == 'getFreeMemory':22        client.send_rpc_reply(request_id, {'memFree': gc.mem_free()})23def main():24    client.set_server_side_rpc_request_handler(handle_rpc_request)25    client.connect()26    # subscribe to future changes of upload frequency27    client.subscribe_to_attribute('telemetryInterval',28                                  on_telemetry_interval_change)29    # fetch the latest setting for upload frequency configured on the server30    client.request_attributes(shared_keys=['telemetryInterval'],31                              callback=on_telemetry_interval_change)...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.