1fd28ded8c2359e2a760df205edae8662f3b7487-PR-13

Committed 28 Jan 2024 10:25AM UTC coverage: 92.059% (-4.4%) from 96.441%

Build # 1fd28ded8c2359e2a760df205edae8662f3b7487-PR-13

Build Type

Pull #13

github

Committed by

pknoth

Commit Message

ebsi in time issuance flow compliance

Pull Request Pull Request #13: OpenID for Verifiable Credential Issuance - draft 11 implementation

Run Details

204 of 261 new or added lines in 30 files covered. (78.16%)

20 existing lines in 10 files now uncovered.

997 of 1083 relevant lines covered (92.06%)

48.73 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

75.0

/lib/boruta/adapters/ecto/codes.ex

defmodule Boruta.Ecto.Codes do
  @moduledoc false
  @behaviour Boruta.Oauth.Codes

  import Boruta.Config, only: [repo: 0]
  import Ecto.Query
  import Boruta.Ecto.OauthMapper, only: [to_oauth_schema: 1]

  alias Boruta.Ecto.Errors
  alias Boruta.Ecto.Token
  alias Boruta.Ecto.TokenStore
  alias Boruta.Oauth

  @impl Boruta.Oauth.Codes
  def get_by(value: value, redirect_uri: redirect_uri) do
    with {:ok, token} <- TokenStore.get(value: value),
         true <- token.redirect_uri == redirect_uri do
      token
    else
      {:error, "Not cached."} ->
        with %Token{} = token <-
               repo().one(
                 from t in Token,
                   where:
                     t.type in ["code", "preauthorized_code"] and t.value == ^value and
                       t.redirect_uri == ^redirect_uri
               ),
             {:ok, token} <-
               token
               |> to_oauth_schema()
               |> TokenStore.put() do
          token
        end

      false ->
        nil
    end
  end

  def get_by(id: id) do
    case TokenStore.get(id: id) do
      {:ok, token} ->
        token

      {:error, "Not cached."} ->
        with %Token{} = token <-
               repo().one(
                 from t in Token,
                   where: t.type in ["code", "preauthorized_code"] and t.id == ^id
               ),
             {:ok, token} <-
               token
               |> to_oauth_schema()
               |> TokenStore.put() do
          token
        end
    end
  end

  def get_by(value: value) do
    case TokenStore.get(value: value) do
      {:ok, token} ->
        token

      {:error, "Not cached."} ->
        with %Token{} = token <-
               repo().one(
                 from t in Token,
                   where: t.type in ["code", "preauthorized_code"] and t.value == ^value
               ),
             {:ok, token} <-
               token
               |> to_oauth_schema()
               |> TokenStore.put() do
          token
        end
    end
  end

  @impl Boruta.Oauth.Codes
  def create(
        %{
          client:
            %Oauth.Client{
              id: client_id,
              authorization_code_ttl: authorization_code_ttl
            } = client,
          redirect_uri: redirect_uri,
          scope: scope,
          state: state,
          code_challenge: code_challenge,
          code_challenge_method: code_challenge_method,
          authorization_details: authorization_details
        } = params
      ) do
    sub = params[:sub]

    changeset =
      apply(Token, changeset_method(client), [
        %Token{resource_owner: params[:resource_owner]},
        %{
          client_id: client_id,
          sub: sub,
          redirect_uri: redirect_uri,
          state: state,
          nonce: params[:nonce],
          scope: scope,
          authorization_code_ttl: authorization_code_ttl,
          code_challenge: code_challenge,
          code_challenge_method: code_challenge_method,
          authorization_details: authorization_details
        }
      ])

    with {:ok, token} <- repo().insert(changeset),
         {:ok, token} <- TokenStore.put(to_oauth_schema(token)) do
      {:ok, token}
    else
      {:error, %Ecto.Changeset{} = changeset} ->
        error_message = Errors.message_from_changeset(changeset)

        {:error, "Could not create code : #{error_message}"}
    end
  end

  defp changeset_method(%Oauth.Client{pkce: false}), do: :code_changeset
  defp changeset_method(%Oauth.Client{pkce: true}), do: :pkce_code_changeset

  @impl Boruta.Oauth.Codes
  def revoke(%Oauth.Token{value: value} = code) do
    with %Token{} = token <- repo().get_by(Token, value: value),
         {:ok, token} <-
           Token.revoke_changeset(token)
           |> repo().update(),
         {:ok, _token} <- TokenStore.invalidate(code) do
      {:ok, token}
    else
      nil ->
        {:error, "Code not found."}

      error ->
        error
    end
  end
end

1	defmodule Boruta.Ecto.Codes do
2	@moduledoc false
3	@behaviour Boruta.Oauth.Codes
4
5	import Boruta.Config, only: [repo: 0]
6	import Ecto.Query
7	import Boruta.Ecto.OauthMapper, only: [to_oauth_schema: 1]
8
9	alias Boruta.Ecto.Errors
10	alias Boruta.Ecto.Token
11	alias Boruta.Ecto.TokenStore
12	alias Boruta.Oauth
13
14	@impl Boruta.Oauth.Codes
15	def get_by(value: value, redirect_uri: redirect_uri) do
16	with {:ok, token} <- TokenStore.get(value: value),	20✔
17	true <- token.redirect_uri == redirect_uri do	1✔
18	token	1✔
19	else
20	{:error, "Not cached."} ->
21	with %Token{} = token <-	19✔
22	repo().one(
23	from t in Token,
24	where:
25	t.type in ["code", "preauthorized_code"] and t.value == ^value and
26	t.redirect_uri == ^redirect_uri
27	),
28	{:ok, token} <-	17✔
29	token
30	\|> to_oauth_schema()
31	\|> TokenStore.put() do
32	token	17✔
33	end
34
35	false ->
36	nil
37	end
38	end
39
40	def get_by(id: id) do
NEW 41	case TokenStore.get(id: id) do	×
42	{:ok, token} ->
NEW 43	token	×
44
45	{:error, "Not cached."} ->
NEW 46	with %Token{} = token <-	×
47	repo().one(
48	from t in Token,
49	where: t.type in ["code", "preauthorized_code"] and t.id == ^id
50	),
NEW 51	{:ok, token} <-	×
52	token
53	\|> to_oauth_schema()
54	\|> TokenStore.put() do
NEW 55	token	×
56	end
57	end
58	end
59
60	def get_by(value: value) do
61	case TokenStore.get(value: value) do	4✔
62	{:ok, token} ->
NEW 63	token	×
64
65	{:error, "Not cached."} ->
66	with %Token{} = token <-	4✔
67	repo().one(
68	from t in Token,
69	where: t.type in ["code", "preauthorized_code"] and t.value == ^value
70	),
71	{:ok, token} <-	3✔
72	token
73	\|> to_oauth_schema()
74	\|> TokenStore.put() do
75	token	3✔
76	end
77	end
78	end
79
80	@impl Boruta.Oauth.Codes
81	def create(
82	%{
83	client:
84	%Oauth.Client{
85	id: client_id,
86	authorization_code_ttl: authorization_code_ttl
87	} = client,
88	redirect_uri: redirect_uri,
89	scope: scope,
90	state: state,
91	code_challenge: code_challenge,
92	code_challenge_method: code_challenge_method,
93	authorization_details: authorization_details
94	} = params
95	) do
96	sub = params[:sub]	34✔
97
98	changeset =	34✔
99	apply(Token, changeset_method(client), [
100	%Token{resource_owner: params[:resource_owner]},
101	%{
102	client_id: client_id,
103	sub: sub,
104	redirect_uri: redirect_uri,
105	state: state,
106	nonce: params[:nonce],
107	scope: scope,
108	authorization_code_ttl: authorization_code_ttl,
109	code_challenge: code_challenge,
110	code_challenge_method: code_challenge_method,
111	authorization_details: authorization_details
112	}
113	])
114
115	with {:ok, token} <- repo().insert(changeset),	34✔
116	{:ok, token} <- TokenStore.put(to_oauth_schema(token)) do	32✔
117	{:ok, token}
118	else
119	{:error, %Ecto.Changeset{} = changeset} ->
120	error_message = Errors.message_from_changeset(changeset)	2✔
121
122	{:error, "Could not create code : #{error_message}"}	2✔
123	end
124	end
125
126	defp changeset_method(%Oauth.Client{pkce: false}), do: :code_changeset	29✔
127	defp changeset_method(%Oauth.Client{pkce: true}), do: :pkce_code_changeset	5✔
128
129	@impl Boruta.Oauth.Codes
130	def revoke(%Oauth.Token{value: value} = code) do
131	with %Token{} = token <- repo().get_by(Token, value: value),	11✔
132	{:ok, token} <-	11✔
133	Token.revoke_changeset(token)
134	\|> repo().update(),
135	{:ok, _token} <- TokenStore.invalidate(code) do	11✔
136	{:ok, token}
137	else
138	nil ->
139	{:error, "Code not found."}
140
141	error ->
UNCOV 142	error	×
143	end
144	end
145	end

malach-it / boruta_auth / 1fd28ded8c2359e2a760df205edae8662f3b7487-PR-13

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous