File Coverage

blib/lib/Mojolicious/Plugin/OAuth2/Mock.pm

Criterion	Covered	Total	%
statement	57	59	96.6
branch	9	14	64.2
condition	12	21	57.1
subroutine	13	14	92.8
pod	1	1	100.0
total	92	109	84.4

package Mojolicious::Plugin::OAuth2::Mock;
use Mojo::Base -base;

require Mojolicious::Plugin::OAuth2;

use constant DEBUG => $ENV{MOJO_OAUTH2_DEBUG} || 0;

has provider => sub {
  return {
    authorization_endpoint_url => '/mocked/oauth2/authorize',
    end_session_endpoint_url   => '/mocked/oauth2/logout',
    issuer_url                 => '/mocked/oauth2/v2.0',
    jwks_url                   => '/mocked/oauth2/keys',
    return_code                => 'fake_code',
    return_token               => 'fake_token',
    token_endpoint_url         => '/mocked/oauth2/token',
  };
};

has _rsa => sub { require Crypt::OpenSSL::RSA; Crypt::OpenSSL::RSA->generate_key(2048) };

sub apply_to {
  my $self = ref $_[0] ? shift : shift->SUPER::new;
  my ($app, $provider) = @_;

  map { $self->provider->{$_} = $provider->{$_} } keys %$provider if $provider;
  push @{$app->renderer->classes}, __PACKAGE__;

  # Add mocked routes for "authorize", "token", ...
  for my $k (keys %{$self->provider}) {
    next unless $k =~ m!^([a-z].+)_url$!;
    my $method = "_action_$1";
    my $url    = $self->provider->{$k};
    warn "[Oauth2::Mock] $url => $method()\n" if DEBUG;
    $app->routes->any($url => sub { $self->$method(@_) });
  }
}

sub _action_authorization_endpoint {
  my ($self, $c) = @_;

  if ($c->param('response_mode') eq 'form_post') {
    return $c->render(
      template     => 'oauth2/mock/form_post',
      format       => 'html',
      code         => "authorize-code",
      redirect_uri => $c->param('redirect_uri'),
      state        => $c->param('state')
    );
  }

  # $c->param('response_mode') eq 'query'
  my $url = Mojo::URL->new($c->param('redirect_uri'));
  $url->query({code => 'authorize-code', state => $c->param('state')});
  return $c->redirect_to($url);
}

sub _action_authorize {
  my ($self, $c) = @_;

  if ($c->param('client_id') and $c->param('redirect_uri')) {
    my $url = Mojo::URL->new($c->param('redirect_uri'));
    $url->query->append(code => $self->provider->{return_code});
    $c->render(text => $c->tag('a', href => $url, sub {'Connect'}));
  }
  else {
    $c->render(text => "Invalid request\n", status => 400);
  }
}

sub _action_end_session_endpoint {
  my ($self, $c) = @_;
  my $rp_url = Mojo::URL->new($c->param('post_logout_redirect_uri'))
    ->query({id_token_hint => $c->param('id_token_hint'), state => $c->param('state')});
  $c->redirect_to($rp_url);
}

sub _action_issuer {
  my ($self, $c) = @_;
}

sub _action_jwks {
  my ($self, $c) = @_;

  my ($n, $e) = $self->_rsa->get_key_parameters;
  my $x5c = $self->_rsa->get_public_key_string;
  $x5c =~ s/\n/\\n/g;

  require MIME::Base64;
  return $c->render(
    template => 'oauth2/mock/keys',
    format   => 'json',
    n        => MIME::Base64::encode_base64url($n->to_bin),
    e        => MIME::Base64::encode_base64url($e->to_bin),
    x5c      => $x5c,
    issuer   => $c->url_for($self->provider->{issuer_url})->to_abs,
  );
}

sub _action_token {
  my ($self, $c) = @_;

  return $c->render(text => 'FAIL OVERFLOW', status => 404)
    unless 3 == grep { $c->param($_) } qw(client_secret redirect_uri code);

  $c->render(
    text => Mojo::Parameters->new(
      access_token  => $self->provider->{return_token},
      expires_in    => 3600,
      refresh_token => Mojo::Util::md5_sum(rand),
      scope         => $self->provider->{scopes} || 'some list of scopes',
      token_type    => 'bearer',
    )->to_string
  );
}

sub _action_token_endpoint {
  my ($self, $c) = @_;
  return $c->render(json => {error => 'invalid_request'}, status => 500)
    unless (($c->param('client_secret') and $c->param('redirect_uri') and $c->param('code'))
    || ($c->param('grant_type') eq 'refresh_token' and $c->param('refresh_token')));

  my $claims = {
    aud                => $c->param('client_id'),
    email              => '[e-mail]',
    iss                => $c->url_for($self->provider->{issuer_url})->to_abs,
    name               => 'foo bar',
    preferred_username => '[e-mail]',
    sub                => 'foo.bar'
  };

  require Mojo::JWT;
  my $id_token = Mojo::JWT->new(
    algorithm => 'RS256',
    secret    => $self->_rsa->get_private_key_string,
    set_iat   => 1,
    claims    => $claims,
    header    => {kid => 'TEST_SIGNING_KEY'}
  );

  return $c->render(
    template      => 'oauth2/mock/token',
    format        => 'json',
    id_token      => $id_token->expires(Mojo::JWT->now + 3600)->encode,
    refresh_token => $c->param('refresh_token') // 'refresh-token',
  );
}

sub _action_well_known {
  my ($self, $c) = @_;
  my $provider = $self->provider;
  my $req_url  = $c->req->url->to_abs;
  my $to_abs   = sub { $req_url->path(Mojo::URL->new(shift)->path)->to_abs };

  $c->render(
    template               => 'oauth2/mock/configuration',
    format                 => 'json',
    authorization_endpoint => $to_abs->($provider->{authorization_endpoint_url}),
    end_session_endpoint   => $to_abs->($provider->{end_session_endpoint_url}),
    issuer                 => $to_abs->($provider->{issuer_url}),
    jwks_uri               => $to_abs->($provider->{jwks_url}),
    token_endpoint         => $to_abs->($provider->{token_endpoint_url}),
  );
}

1;

=encoding utf8

=head1 NAME

Mojolicious::Plugin::OAuth2::Mock - Mock an Oauth2 and/or OpenID Connect provider

=head1 SYNOPSIS

  use Mojolicious::Plugin::OAuth2::Mock;
  use Mojolicious;

  my $app = Mojolicious->new;
  Mojolicious::Plugin::OAuth2::Mock->apply_to($app);

=head1 DESCRIPTION

L is an EXPERIMENTAL module to make it
easier to test your L based code.

=head1 METHODS

=head2 apply_to

  Mojolicious::Plugin::OAuth2::Mock->apply_to($app, \%provider_args);
  $mock->apply_to($app, \%provider_args);

Used to add mocked routes to a L application, based on all the
keys in C<%provider_args> that end with "_url". Example:


  * authorize_url              => /mocked/oauth/authorize
  * authorization_endpoint_url => /mocked/oauth2/authorize
  * end_session_endpoint_url   => /mocked/oauth2/logout
  * issuer_url                 => /mocked/oauth2/v2.0
  * jwks_url                   => /mocked/oauth2/keys
  * token_url                  => /mocked/oauth/token
  * token_endpoint_url         => /mocked/oauth2/token

=head1 SEE ALSO

L.

=cut

__DATA__