megaco_pending_limit_test.erl

来自「OTP是开放电信平台的简称」· ERL 代码 · 共 2,019 行 · 第 1/5 页

-define(otp_4956_mgc_verify_notify_req2_fun(),
        otp_4956_mgc_verify_notify_req2_fun()).
-define(otp_4956_mgc_verify_handle_trans_req_abort_fun(),
	otp_4956_mgc_verify_handle_trans_req_abort_fun()).
-define(otp_4956_mgc_verify_handle_disconnect_fun(),
	fun otp_4956_mgc_verify_handle_disconnect/1).
-endif.

otp_4956_mgc_event_sequence(text, tcp) ->
    Mid = {deviceName,"ctrl"},
    RI = [
          {port,             2944},
          {encoding_module,  megaco_pretty_text_encoder},
          {encoding_config,  []},
          {transport_module, megaco_tcp}
         ],
    ConnectVerify          = ?otp_4956_mgc_verify_handle_connect_fun(),
    ServiceChangeReqVerify = ?otp_4956_mgc_verify_service_change_req_fun(Mid),
    NotifyReqVerify1       = ?otp_4956_mgc_verify_notify_req1_fun(),
    NotifyReqVerify2       = ?otp_4956_mgc_verify_notify_req2_fun(),
    ReqAbortVerify         = ?otp_4956_mgc_verify_handle_trans_req_abort_fun(), 
    DiscoVerify            = ?otp_4956_mgc_verify_handle_disconnect_fun(), 
%%     ConnectVerify          = otp_4956_mgc_verify_handle_connect_fun(),
%%     ServiceChangeReqVerify = otp_4956_mgc_verify_service_change_req_fun(Mid),
%%     NotifyReqVerify1       = otp_4956_mgc_verify_notify_request_fun1(),
%%     NotifyReqVerify2       = otp_4956_mgc_verify_notify_request_fun2(),
%%     ReqAbortVerify = otp_4956_mgc_verify_handle_trans_request_abort_fun(), 
%%     DiscoVerify            = fun otp_4956_mgc_verify_handle_disconnect/1,
    EvSeq = [
             {debug, true},
	     {megaco_trace, disable},
	     {megaco_trace, max},
             megaco_start,
             {megaco_start_user, Mid, RI, []},
	     {megaco_update_user_info, sent_pending_limit, 4},
             start_transport,
             listen,
             {megaco_callback, handle_connect, ConnectVerify},
	     {megaco_conn_info, all},
             {megaco_callback, handle_trans_request_sc, ServiceChangeReqVerify},
             {megaco_callback, handle_trans_request_1, NotifyReqVerify1},
             {megaco_callback, handle_trans_request_abort, ReqAbortVerify},
             {megaco_callback, nocall, 1000},
             {megaco_callback, handle_trans_request_6, NotifyReqVerify2},
             {megaco_callback, handle_disconnect, DiscoVerify},
             megaco_stop_user,
             megaco_stop
            ],
    EvSeq.


-ifndef(megaco_hipe_special).
otp_4956_mgc_verify_handle_connect_fun() ->
    fun(M) ->
	    otp_4956_mgc_verify_handle_connect(M)
    end.
-endif.

otp_4956_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 
    {ok, CH, ok};
otp_4956_mgc_verify_handle_connect(Else) ->
    {error, Else, ok}.

-ifndef(megaco_hipe_special).
otp_4956_mgc_verify_service_change_req_fun(Mid) ->
    fun(Req) ->
	    otp_4956_mgc_verify_service_change_req(Req, Mid)
    end.
-endif.

otp_4956_mgc_verify_service_change_req(
  {handle_trans_request, _, ?VERSION, [AR]}, Mid) ->
    io:format("otp_4956_mgc_verify_service_change_req -> ok"
	      "~n   AR: ~p~n", [AR]),
    case AR of
	#'ActionRequest'{commandRequests = [CR]} ->
	    case CR of
		#'CommandRequest'{command = Cmd} ->
		    case Cmd of
			{serviceChangeReq, 
			 #'ServiceChangeRequest'{terminationID = [Tid],
						 serviceChangeParms = Parms}} ->
			    case Tid of
				#megaco_term_id{contains_wildcards = false, 
						id = ["root"]} ->
				    case Parms of
					#'ServiceChangeParm'{
						 serviceChangeMethod = restart,
						 serviceChangeReason = [[$9,$0,$1|_]]} ->
					    Reply = 
						{discard_ack, 
						 [otp_4956_mgc_service_change_reply_ar(Mid, 1)]},
					    {ok, AR, Reply};
					_ ->
					    Err = {invalid_SCP, Parms},
					    ED = otp_4956_err_desc(Parms),
					    ErrReply = {discard_ack, ED},
					    {error, Err, ErrReply}
				    end;
				_ ->
				    Err = {invalid_termination_id, Tid},
				    ED = otp_4956_err_desc(Tid),
				    ErrReply = {discard_ack, ED},
				    {error, Err, ErrReply}
			    end;
			_ ->
			    Err = {invalid_command, Cmd},
			    ED = otp_4956_err_desc(Cmd),
			    ErrReply = {discard_ack, ED},
			    {error, Err, ErrReply}
		    end;
		_ ->
		    Err = {invalid_command_request, CR},
		    ED = otp_4956_err_desc(CR),
		    ErrReply = {discard_ack, ED},
		    {error, Err, ErrReply}
	    end;
	_ ->
	    Err = {invalid_action_request, AR},
	    ED = otp_4956_err_desc(AR),
	    ErrReply = {discard_ack, ED},
	    {error, Err, ErrReply}
    end;
otp_4956_mgc_verify_service_change_req(Else, _Mid) ->
    io:format("otp_4956_mgc_verify_service_change_req -> unknown"
	      "~n   Else: ~p~n", [Else]),
    ED       = otp_4956_err_desc(Else),
    ErrReply = {discard_ack, ED},
    {error, Else, ErrReply}.

-ifndef(megaco_hipe_special).
otp_4956_mgc_verify_notify_req1_fun() ->
    fun(Req) ->
	    otp_4956_mgc_verify_notify_req1(Req)
    end.
-endif.

otp_4956_mgc_verify_notify_req1({handle_trans_request, _, ?VERSION, [AR]}) ->
    io:format("otp_4956_mgc_verify_notify_req1 -> entry with"
	      "~n   AR: ~p"
	      "~n", [AR]),
    case AR of
	#'ActionRequest'{contextId = Cid, 
			 commandRequests = [CR]} ->
	    #'CommandRequest'{command = Cmd} = CR,
	    {notifyReq, NR} = Cmd,
	    #'NotifyRequest'{terminationID = [Tid],
			     observedEventsDescriptor = OED,
			     errorDescriptor = asn1_NOVALUE} = NR,
	    #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED,
	    #'ObservedEvent'{eventName = "al/of"} = OE,
	    Reply = {discard_ack, [otp_4956_mgc_notify_reply_ar(Cid, Tid)]},
	    {ok, 6500, AR, Reply};
	_ ->
                    ED = otp_4956_err_desc(AR),
	    ErrReply = {discard_ack, ED},
	    {error, AR, ErrReply}
    end;
otp_4956_mgc_verify_notify_req1(Else) ->
    io:format("otp_4956_mgc_verify_notify_req1 -> entry with"
	      "~n   Else: ~p"
	      "~n", [Else]),
    ED       = otp_4956_err_desc(Else),
    ErrReply = {discard_ack, ED},
    {error, Else, ErrReply}.

-ifndef(megaco_hipe_special).
otp_4956_mgc_verify_notify_req2_fun() ->
    fun(Ev) ->
	    otp_4956_mgc_verify_notify_req2(Ev)
    end.
-endif.

otp_4956_mgc_verify_notify_req2({handle_trans_request, _, ?VERSION, [AR]}) ->
    case AR of
	#'ActionRequest'{contextId = _Cid, 
			 commandRequests = [CR]} ->
	    #'CommandRequest'{command = Cmd} = CR,
	    {notifyReq, NR} = Cmd,
	    #'NotifyRequest'{terminationID = [_Tid],
			     observedEventsDescriptor = OED,
			     errorDescriptor = asn1_NOVALUE} = NR,
	    #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED,
	    #'ObservedEvent'{eventName = "al/of"} = OE,
	    Reply = ignore,
	    {ok, 100, AR, Reply};
	_ ->
	    ED = otp_4956_err_desc(AR),
	    ErrReply = {discard_ack, ED},
	    {error, AR, ErrReply}
    end;
otp_4956_mgc_verify_notify_req2(Else) ->
    ED       = otp_4956_err_desc(Else),
    ErrReply = {discard_ack, ED},
    {error, Else, ErrReply}.

-ifndef(megaco_hipe_special).
otp_4956_mgc_verify_handle_trans_req_abort_fun() ->
    fun(Req) -> 
	    otp_4956_mgc_verify_handle_trans_req_abort(Req)
    end.
-endif.

otp_4956_mgc_verify_handle_trans_req_abort({handle_trans_request_abort, 
					    CH, ?VERSION, 2, Pid}) -> 
    io:format("otp_4956_mgc_verify_handle_trans_req_abort -> ok"
	      "~n   CH:  ~p"
	      "~n   Pid: ~p"
	      "~n", [CH, Pid]),
    {ok, {CH, Pid}, ok};
otp_4956_mgc_verify_handle_trans_req_abort({handle_trans_request_abort, 
					    CH, Version, TransId, Pid}) -> 
    io:format("otp_4956_mgc_verify_handle_trans_req_abort -> error"
	      "~n   CH:      ~p"
	      "~n   Version: ~p"
	      "~n   TransId: ~p"
	      "~n   Pid:     ~p"
	      "~n", [CH, Version, TransId, Pid]),
    {error, {error, {invalid_version_trans_id, Version, TransId}}, ok};
otp_4956_mgc_verify_handle_trans_req_abort(Else) ->
    io:format("otp_4956_mgc_verify_handle_trans_req_abort -> error"
	      "~n   Else: ~p"
	      "~n", [Else]),
    {error, Else, ok}.

otp_4956_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, _R}) -> 
    io:format("otp_4956_mgc_verify_handle_disconnect -> ok"
	      "~n   CH: ~p"
	      "~n   _R:  ~p"
	      "~n", [CH, _R]),
    {ok, CH, ok};
otp_4956_mgc_verify_handle_disconnect(Else) ->
    io:format("otp_4956_mgc_verify_handle_disconnect -> unknown"
	      "~n   Else: ~p~n", [Else]),
    {error, Else, ok}.

otp_4956_mgc_service_change_reply_ar(Mid, Cid) ->
    SCRP  = cre_serviceChangeResParm(Mid),
    SCRes = cre_serviceChangeResult(SCRP),
    Root  = #megaco_term_id{id = ["root"]},
    SCR   = cre_serviceChangeReply([Root], SCRes),
    CR    = cre_cmdReply(SCR),
    AR    = cre_actionReply(Cid, [CR]),
    AR.

%% otp_4956_mgc_service_change_reply_msg(Mid, TransId, Cid) ->
%%     AR    = otp_4956_mgc_service_change_reply_ar(Mid, Cid),
%%     TRes  = cre_transResult([AR]),
%%     TR    = cre_transReply(TransId, TRes),
%%     Trans = cre_transaction(TR),
%%     Mess  = cre_message(?VERSION, Mid, cre_transactions([Trans])),
%%     cre_megacoMessage(Mess).

otp_4956_mgc_notify_reply_ar(Cid, TermId) ->
    NR    = cre_notifyReply([TermId]),
    CR    = cre_cmdReply(NR),
    cre_actionReply(Cid, [CR]).

%% otp_4956_mgc_notify_reply(Mid, TransId, Cid, TermId) ->
%%     AR    = otp_4956_mgc_notify_reply_ar(Cid, TermId),
%%     TRes  = cre_transResult([AR]),
%%     TR    = cre_transReply(TransId, TRes),
%%     Trans = cre_transaction(TR),
%%     Mess  = cre_message(?VERSION, Mid, cre_transactions([Trans])),
%%     cre_megacoMessage(Mess).


%%
%% MG generator stuff
%% 
-ifdef(megaco_hipe_special).
-define(otp_4956_mg_decode_msg_fun(Mod, Conf),
	{?MODULE, decode_msg, [Mod, Conf]}).
-define(otp_4956_mg_encode_msg_fun(Mod, Conf),
	{?MODULE, encode_msg, [Mod, Conf]}).
-define(otp_4956_mg_verify_service_change_rep_msg_fun(),
	{?MODULE, otp_4956_mg_verify_service_change_rep_msg, []}).
-define(otp_4956_mg_verify_pending_msg_fun(),
	{?MODULE, otp_4956_mg_verify_pending_msg, []}).
-define(otp_4956_mg_verify_pending_limit_msg_fun(),
	{?MODULE, otp_4956_mg_verify_pending_limit_msg, []}).
-else.
-define(otp_4956_mg_decode_msg_fun(Mod, Conf),
	otp_4956_mg_decode_msg_fun(Mod, Conf)).
-define(otp_4956_mg_encode_msg_fun(Mod, Conf),
	otp_4956_mg_encode_msg_fun(Mod, Conf)).
-define(otp_4956_mg_verify_service_change_rep_msg_fun(),
	otp_4956_mg_verify_service_change_rep_msg_fun()).
-define(otp_4956_mg_verify_pending_msg_fun(),
	otp_4956_mg_verify_pending_msg_fun()).
-define(otp_4956_mg_verify_pending_limit_msg_fun(),
	otp_4956_mg_verify_pending_limit_msg_fun()).
-endif.

otp_4956_mg_event_sequence(text, tcp) ->
    DecodeFun = ?otp_4956_mg_decode_msg_fun(megaco_pretty_text_encoder, []),
    EncodeFun = ?otp_4956_mg_encode_msg_fun(megaco_pretty_text_encoder, []),
    Mid = {deviceName,"mg"},
    ServiceChangeReq = otp_4956_mg_service_change_request_msg(Mid, 1, 0),
    TermId = #megaco_term_id{id = ["00000000","00000000","01101101"]},
    NotifyReq = otp_4956_mg_notify_request_msg(Mid, 2, 1, TermId, 1),
    ServiceChangeReplyVerifyFun = ?otp_4956_mg_verify_service_change_rep_msg_fun(),
    PendingVerify               = ?otp_4956_mg_verify_pending_msg_fun(),
    PendingLimitVerify          = ?otp_4956_mg_verify_pending_limit_msg_fun(),
%%     ServiceChangeReplyVerifyFun = 
%% 	otp_4956_mg_verify_service_change_rep_msg_fun(),
%%     PendingVerify = otp_4956_mg_verify_pending_msg_fun(),
%%     PendingLimitVerify = otp_4956_mg_verify_pending_limit_msg_fun(),
    EvSeq = [{debug,  true},
	     {decode, DecodeFun},
	     {encode, EncodeFun},
	     {connect, 2944},
	     {send, "service-change-request", ServiceChangeReq}, 
	     {expect_receive, "service-change-reply", {ServiceChangeReplyVerifyFun, 10000}}, 
	     {send, "notify request (first send)", NotifyReq}, 
	     {sleep, 100},
	     {send, "notify request (resend 1)", NotifyReq}, 
	     {expect_receive, "pending 1", {PendingVerify, 1000}},
	     {sleep, 1000},
	     {send, "notify request (resend 2)", NotifyReq}, 
	     {expect_receive, "pending 2", {PendingVerify, 1000}},
	     {sleep, 1000},
	     {send, "notify request (resend 3)", NotifyReq}, 
	     {expect_receive, "pending 3", {PendingVerify, 1000}},
	     {sleep, 1000},
	     {send, "notify request (resend 4)", NotifyReq}, 
	     {expect_receive, "pending 4", {PendingVerify, 1000}},
	     {sleep, 1000},
	     {send, "notify request (resend 5)", NotifyReq}, 
	     {expect_receive, "pending limit exceeded", 
	      {PendingLimitVerify, 1000}},
	     {sleep, 4000},
	     {send, "notify request (resend 6)", NotifyReq}, 
	     {expect_nothing, 4000},
	     disconnect
	    ],
    EvSeq.

otp_4956_mg_encode_msg_fun(Mod, Conf) ->
    fun(M) -> 
            encode_msg(M, Mod, Conf)
    end.

otp_4956_mg_decode_msg_fun(Mod, Conf) ->
    fun(M) -> 
            decode_msg(M, Mod, Conf)
    end.

-ifndef(megaco_hipe_special).
otp_4956_mg_verify_service_change_rep_msg_fun() ->
    fun(M) ->
	    otp_4956_mg_verify_service_change_rep_msg(M)
    end.
-endif.

otp_4956_mg_verify_service_change_rep_msg(
  #'MegacoMessage'{mess = Mess} = M) -> 
    io:format("otp_4956_mg_verify_service_change_rep_msg -> "
	      "ok so far~n",[]),
    #'Message'{version     = _V,
	       mId         = _MgMid,
	       messageBody = Body} = Mess,
    {transactions, [Trans]} = Body,
    {transactionReply, TR} = Trans,
    #'TransactionReply'{transactionId = _Tid,
			immAckRequired = asn1_NOVALUE,
			transactionResult = Res} = TR,
    {actionReplies, [AR]} = Res,
    #'ActionReply'{contextId = _Cid,
		   errorDescriptor = asn1_NOVALUE,
		   contextReply = _CtxReq,
		   commandReply = [CR]} = AR,
    {serviceChangeReply, SCR} = CR,
    #'ServiceChangeReply'{terminationID = _TermID,
			  serviceChangeResult = SCRes} = SCR,
    {serviceChangeResParms, SCRP} = SCRes,
    #'ServiceChangeResParm'{serviceChangeMgcId = _MgcMid} = SCRP,
    {ok, M};
otp_4956_mg_verify_service_change_rep_msg(M) ->
    {error, {invalid_message, M}}.

-ifndef(megaco_hipe_special).
otp_4956_mg_verify_pending_msg_fun() ->
    fun(M) ->
	    otp_4956_mg_verify_pending_msg(M)
    end.
-endif.

otp_4956_mg_verify_pending_msg(#'MegacoMessage'{mess = Mess} = M) ->
    print("otp_4956_mg_verify_pending_msg -> entry with"
	  "~n~p", [M]),
    #'Message'{messageBody = Body} = Mess,
    {transactions, [Trans]} = Body,
    {transactionPending, TP} = Trans,
    #'TransactionPending'{transactionId = _Id} = TP,
    print("otp_4956_mg_verify_pending_msg -> done~n", []),
    {ok, M};
otp_4956_mg_verify_pending_msg(M) ->
    print("otp_4956_mg_verify_pending_msg -> entry with invalid message"
	  "~n~p", [M]),
    {error, {invalid_message, M}}.

-ifndef(megaco_hipe_special).
otp_4956_mg_verify_pending_limit_msg_fun() ->