Make all Jw[<lowercase>] JW[<uppercase>] for readability

src/id_token_jwks.erl

@@ -33,8 +33,8 @@ get_pub_keys(Uri) ->
 get_jwks_uri(Uri) ->
   case hackney:request(get, Uri, [], <<>>, [with_body]) of
     {ok, 200, _Headers, Body} ->
-      #{<<"jwks_uri">> := JwksUri} = jsx:decode(Body, [return_maps]),
-      {ok, JwksUri};
+      #{<<"jwks_uri">> := JWKSUri} = jsx:decode(Body, [return_maps]),
+      {ok, JWKSUri};
     {ok, _, _, _} ->
       {error, service_unavailable};
     {error, Reason} ->

src/id_token_jws.erl

@@ -72,8 +72,8 @@ generate_key_for(Alg, Options) ->
           <<"ES", _S/binary>> -> generate_ec_key(Alg, Options);
           _ -> generate_rsa_key(Alg, Options)
         end,
-  Jwk0 = jose_jwk:from_key(Key),
-  JWK = Jwk0#jose_jwk{fields = #{<<"kid">> => kid(Options),
+  JWK0 = jose_jwk:from_key(Key),
+  JWK = JWK0#jose_jwk{fields = #{<<"kid">> => kid(Options),
                                  <<"use">> => <<"sig">>,
                                  <<"iat">> => iat(Options)}},
   {_, PublicKeyMap} = jose_jwk:to_public_map(JWK),

src/id_token_sign.erl

@@ -75,8 +75,8 @@ handle_info(_Request, Timers0) ->
 %%% Internal functions
 %%%===================================================================
 put_key_for(Alg, Options) ->
-  {Jwk, PublicKeyMap} = id_token_jws:generate_key_for(Alg, Options),
-  SignKeyFun = fun() -> Jwk end,
+  {JWK, PublicKeyMap} = id_token_jws:generate_key_for(Alg, Options),
+  SignKeyFun = fun() -> JWK end,
   #{<<"kid">> := Kid, <<"iat">> := Iat} = PublicKeyMap,
   TTU = maps:get(ttu, Options, ?TTU),
   Exp = Iat + TTU,

test/id_token_SUITE.erl

@@ -19,26 +19,26 @@ init_per_suite(Config) ->
 end_per_suite(_Config) -> ok.
 
 init_per_testcase(_TestCase, Config) ->
-  {Jwk, PublicKeyMap} =
+  {JWK, PublicKeyMap} =
     id_token_jws:generate_key_for(<<"RS256">>, #{key_size => 1024}),
   Claims = #{ <<"exp">> => erlang:system_time(second) + 10},
-  Jwt = id_token_jws:sign(Claims, Jwk),
+  JWT = id_token_jws:sign(Claims, JWK),
   mock_id_provider(PublicKeyMap, 0),
   application:ensure_all_started(id_token),
-  [{jwt, Jwt}, {pubkeys, [PublicKeyMap]} | Config].
+  [{jwt, JWT}, {pubkeys, [PublicKeyMap]} | Config].
 end_per_testcase(_TestCase, Config) ->
   application:stop(id_token),
   meck:unload([id_token_jwks, hackney]),
   Config.
 
 validate_jwt(Config) ->
-  Jwt = ?config(jwt, Config),
-  ?assertMatch({ok, _}, id_token:validate(?ID_PROVIDER, Jwt)).
+  JWT = ?config(jwt, Config),
+  ?assertMatch({ok, _}, id_token:validate(?ID_PROVIDER, JWT)).
 
 keys_are_cached(Config) ->
-  Jwt = ?config(jwt, Config),
-  ?assertMatch({ok, _}, id_token:validate(?ID_PROVIDER, Jwt)),
-  ?assertMatch({ok, _}, id_token:validate(?ID_PROVIDER, Jwt)),
+  JWT = ?config(jwt, Config),
+  ?assertMatch({ok, _}, id_token:validate(?ID_PROVIDER, JWT)),
+  ?assertMatch({ok, _}, id_token:validate(?ID_PROVIDER, JWT)),
   1 = meck:num_calls(id_token_jwks, get_pub_keys, 1),
   ok.
 
@@ -49,24 +49,24 @@ keys_are_only_refreshed_once_per_kid(Config) ->
   ok = meck:expect(id_token_provider, get_cached_keys, 1, CurrentKeyCache),
 
   %% create JWT with kid that's not yet in the pubkey cache
-  {Jwk, NewPubkey} = id_token_jws:generate_key_for(<<"RS256">>, #{key_size => 1024}),
+  {JWK, NewPubkey} = id_token_jws:generate_key_for(<<"RS256">>, #{key_size => 1024}),
   Claims = #{ <<"exp">> => erlang:system_time(second) + 10 },
-  Jwt = id_token_jws:sign(Claims, Jwk),
+  JWT = id_token_jws:sign(Claims, JWK),
 
   %% set up provider to return new pubkeys with a 50 ms delay
   HttpReponseDelay = 50,
   mock_id_provider(NewPubkey, HttpReponseDelay),
   ?assertEqual(0, meck:num_calls(id_token_jwks, get_pub_keys, 1)),
 
   %% try to validate multiple JWTs based on kid that's not yet in the key cache
-  spawn(fun() -> id_token:validate(?ID_PROVIDER, Jwt) end),
-  spawn(fun() -> id_token:validate(?ID_PROVIDER, Jwt) end),
-  spawn(fun() -> id_token:validate(?ID_PROVIDER, Jwt) end),
+  spawn(fun() -> id_token:validate(?ID_PROVIDER, JWT) end),
+  spawn(fun() -> id_token:validate(?ID_PROVIDER, JWT) end),
+  spawn(fun() -> id_token:validate(?ID_PROVIDER, JWT) end),
   timer:sleep(10 * HttpReponseDelay),
 
   %% ensure that the pubkey cache was only refreshed once
   ?assertEqual(1, meck:num_calls(id_token_jwks, get_pub_keys, 1)),
-  ?assertMatch({ok, _}, id_token:validate(?ID_PROVIDER, Jwt)),
+  ?assertMatch({ok, _}, id_token:validate(?ID_PROVIDER, JWT)),
 
   meck:unload([id_token_provider]).
 

test/prop_id_token_jwt.erl

@@ -26,36 +26,36 @@ eunit_test_() ->
 %%% Properties %%%
 %%%%%%%%%%%%%%%%%%
 prop_valid_signature() ->
-  ?FORALL({{Jwk, PublicKeyMap}, Claims},
+  ?FORALL({{JWK, PublicKeyMap}, Claims},
           {key_pair(), jwt_claims()},
           begin
             #{<<"exp">> := Exp} = Claims,
-            Jwt = id_token_jws:sign(Claims, Jwk),
-            Result = id_token_jws:validate(Jwt, [PublicKeyMap]),
+            JWT = id_token_jws:sign(Claims, JWK),
+            Result = id_token_jws:validate(JWT, [PublicKeyMap]),
             Exp =<  erlang:system_time(second)
               andalso {error, expired} =:= Result
               orelse {ok, Claims} =:= Result
           end).
 
 prop_invalid_signature() ->
-  ?FORALL({{Jwk, PublicKeyMap}, {OtherJwk, OtherPublicKeyMap}, Claims},
+  ?FORALL({{JWK, PublicKeyMap}, {OtherJWK, OtherPublicKeyMap}, Claims},
           {key_pair(), key_pair(), jwt_claims()},
           begin
-            #jose_jwk{fields = OtherFields} = OtherJwk,
-            JwkWithChangedKid = Jwk#jose_jwk{fields = OtherFields},
-            Jwt = id_token_jws:sign(Claims, JwkWithChangedKid),
+            #jose_jwk{fields = OtherFields} = OtherJWK,
+            JWKWithChangedKid = JWK#jose_jwk{fields = OtherFields},
+            JWT = id_token_jws:sign(Claims, JWKWithChangedKid),
             {error, invalid_signature}
-              =:= id_token_jws:validate(Jwt, [OtherPublicKeyMap])
+              =:= id_token_jws:validate(JWT, [OtherPublicKeyMap])
           end).
 
 prop_no_matching_key() ->
-  ?FORALL({[{Jwk, PublicKeyMap} | OtherKeys], Claims},
+  ?FORALL({[{JWK, PublicKeyMap} | OtherKeys], Claims},
           {non_empty(list(key_pair())), jwt_claims()},
           begin
-            Jwt = id_token_jws:sign(Claims, Jwk),
+            JWT = id_token_jws:sign(Claims, JWK),
             PublicKeys = lists:map(fun({_, Key}) -> Key end, OtherKeys),
             {error, no_public_key_matches}
-              =:= id_token_jws:validate(Jwt, PublicKeys)
+              =:= id_token_jws:validate(JWT, PublicKeys)
           end).
 
 %%%%%%%%%%%%%%%%%%