anchor.diff:                  Server = binary_to_list(proplists:get_value(<<"openid.op_endpoint">>, FullKeyValueList)),
                   ?assertEqual({Server, gui_str:to_list(FullCorrectRequest)}, openid_utils:prepare_validation_parameters()),
                   ?assert(meck:validate(gui_utils)),
  -                ?assert(meck:validate(cowboy_req)),
  -                ?assert(meck:validate(wf_context)),
  +                ?assert(meck:validate(gui_ctx)),
                   ?assert(meck:validate(wf))
               end},
   
               {"Missing 'signed' parameter case",
                   fun() ->
  -                    meck:expect(wf_context, context, fun() -> #context{req = []} end),
  -                    meck:expect(cowboy_req, body_qs,
  -                        fun(_) ->
  -                            {ok, [], []}
  +                    meck:expect(gui_ctx, get_request_params,
  +                        fun() ->
  +                            []
                           end),
                       meck:expect(lager, log, fun(error, _, _) -> ok end),
   
                       ?assertEqual({error, invalid_request},
                           openid_utils:prepare_validation_parameters()),
  -                    ?assert(meck:validate(cowboy_req)),
  -                    ?assert(meck:validate(wf_context)),
  +                    ?assert(meck:validate(gui_ctx)),
                       ?assert(meck:validate(lager))
                   end},
   
               {"Missing parameters case",
                   fun() ->
                       meck:expect(wf_context, context, fun() -> #context{req = []} end),
  -                    meck:expect(cowboy_req, body_qs,
  -                        fun(_) ->
  -                            {ok, [
  +                    meck:expect(gui_ctx, get_request_params,
  +                        fun() ->
  +                            [
                                   ?mock_signed_params,
                                   {<<"openid.op_endpoint">>, <<"serverAddress">>}
  -                            ], []}
  +                            ]
                           end),
                       meck:expect(lager, log, fun(error, _, _) -> ok end),
                       meck:expect(wf, url_encode, fun(Key) -> Key end),
   
                       ?assertEqual({error, invalid_request},
                           openid_utils:prepare_validation_parameters()),
  -                    ?assert(meck:validate(cowboy_req)),
  -                    ?assert(meck:validate(wf_context)),
  +                    ?assert(meck:validate(gui_ctx)),
                       ?assert(meck:validate(wf)),
                       ?assert(meck:validate(lager))
                   end},
  
positive.code:                 meck:expect(gui_utils, https_get, fun(_, _) -> {ok, <<?mock_xrds_file>>} end),
                  KeyValueList = lists:zip(openid_keys(), openid_values()),
                  FullKeyValueList = KeyValueList ++ [?mock_signed_params],
                  meck:expect(wf_context, context, fun() -> #context{req = []} end),
                  meck:expect(cowboy_req, body_qs,
                      fun(_) ->
                          {ok, FullKeyValueList, []}
                      end),
  
                  meck:expect(wf, url_encode, fun(Key) -> Key end),
  
negative.code:                     KeyValueList = lists:zip(user_info_keys() -- [<<?openid_dn1_key>>, <<?openid_dn3_key>>],
                          user_info_values() -- [<<"dn1">>, <<"dn3">>]) ++ [?mock_signed_params],
                      meck:expect(wf_context, context, fun() -> #context{req = []} end),
                      meck:expect(gui_ctx, get_request_params,
                          fun() ->
                              KeyValueList
                          end),
  
                      CorrectResult =
  