def test_does_not_need_refresh(self):
        authn = OIDCAuthentication(
            self.app,
            provider_configuration_info={'issuer': ISSUER},
            client_registration_info={
                'client_id': 'foo',
                'session_refresh_interval_seconds': 1
            },
        )
        client_mock = MagicMock()
        callback_mock = MagicMock()
        now = time.time()
        callback_mock.__name__ = 'test_callback'  # required for Python 2
        authn.client = client_mock
        id_token = IdToken(**{'sub': 'sub1', 'nonce': 'nonce', 'exp': 0})
        with self.app.test_request_context('/'):
            flask.session['destination'] = '/'
            flask.session['access_token'] = 'test token'
            flask.session['id_token'] = id_token.to_dict()
            flask.session['id_token_jwt'] = id_token.to_jwt()
            flask.session['last_authenticated'] = now + 100
            authn.oidc_auth(callback_mock)()
            session = Session(
                flask_session=flask.session,
                client_registration_info=authn.client_registration_info)

            assert session.needs_refresh() is False
 def test_dont_reauthenticate_with_valid_id_token(self):
     authn = OIDCAuthentication(self.app, provider_configuration_info={'issuer': ISSUER},
                                client_registration_info={'client_id': 'foo'})
     client_mock = MagicMock()
     callback_mock = MagicMock()
     callback_mock.__name__ = 'test_callback'  # required for Python 2
     authn.client = client_mock
     with self.app.test_request_context('/'):
         flask.session['destination'] = '/'
         flask.session['id_token'] = {'exp': time.time() + 25}
         authn.oidc_auth(callback_mock)()
     assert not client_mock.construct_AuthorizationRequest.called
     assert callback_mock.called is True
Exemple #3
0
 def test_reauthenticate_if_no_session(self):
     authn = OIDCAuthentication(
         self.app,
         provider_configuration_info={'issuer': ISSUER},
         client_registration_info={'client_id': 'foo'})
     client_mock = MagicMock()
     callback_mock = MagicMock()
     callback_mock.__name__ = 'test_callback'  # required for Python 2
     authn.client = client_mock
     with self.app.test_request_context('/'):
         authn.oidc_auth(callback_mock)()
     assert client_mock.construct_AuthorizationRequest.called
     assert not callback_mock.called
Exemple #4
0
 def test_dont_reauthenticate_with_valid_id_token(self):
     authn = OIDCAuthentication(
         self.app,
         provider_configuration_info={'issuer': ISSUER},
         client_registration_info={'client_id': 'foo'})
     client_mock = MagicMock()
     callback_mock = MagicMock()
     callback_mock.__name__ = 'test_callback'  # required for Python 2
     authn.client = client_mock
     with self.app.test_request_context('/'):
         flask.session['destination'] = '/'
         flask.session['access_token'] = 'test token'
         authn.oidc_auth(callback_mock)()
     assert not client_mock.construct_AuthorizationRequest.called
     assert callback_mock.called is True
 def test_reauthenticate_if_no_session(self):
     authn = OIDCAuthentication(
         self.app,
         provider_configuration_info={'issuer': ISSUER},
         client_registration_info={'client_id': 'foo'},
     )
     client_mock = MagicMock()
     callback_mock = MagicMock()
     callback_mock.__name__ = 'test_callback'  # required for Python 2
     authn.client = client_mock
     id_token = IdToken(**{'sub': 'sub1', 'nonce': 'nonce'})
     with self.app.test_request_context('/'):
         flask.session['destination'] = '/'
         flask.session['access_token'] = None
         flask.session['id_token_jwt'] = None
         authn.oidc_auth(callback_mock)()
     assert client_mock.construct_AuthorizationRequest.called is True
     assert callback_mock.called is False
Exemple #6
0
 def test_dont_reauthenticate_silent_if_authentication_not_expired(self):
     authn = OIDCAuthentication(
         self.app,
         provider_configuration_info={'issuer': ISSUER},
         client_registration_info={
             'client_id': 'foo',
             'session_refresh_interval_seconds': 999
         })
     client_mock = MagicMock()
     callback_mock = MagicMock()
     callback_mock.__name__ = 'test_callback'  # required for Python 2
     authn.client = client_mock
     with self.app.test_request_context('/'):
         flask.session['last_authenticated'] = time.time(
         )  # freshly authenticated
         authn.oidc_auth(callback_mock)()
     assert not client_mock.construct_AuthorizationRequest.called
     assert callback_mock.called
    def test_authenticated_session(self):
        authn = OIDCAuthentication(
            self.app,
            provider_configuration_info={'issuer': ISSUER},
            client_registration_info={'client_id': 'foo'},
        )
        client_mock = MagicMock()
        callback_mock = MagicMock()
        callback_mock.__name__ = 'test_callback'  # required for Python 2
        authn.client = client_mock
        id_token = IdToken(**{'sub': 'sub1', 'nonce': 'nonce', 'exp': 0})
        with self.app.test_request_context('/'):
            flask.session['destination'] = '/'
            flask.session['access_token'] = 'test token'
            flask.session['id_token'] = id_token.to_dict()
            flask.session['id_token_jwt'] = id_token.to_jwt()
            authn.oidc_auth(callback_mock)()
            session = Session(
                flask_session=flask.session,
                client_registration_info=authn.client_registration_info)

            assert session.authenticated() is True
    def test_unauthenticated_session_with_refresh(self):
        authn = OIDCAuthentication(
            self.app,
            provider_configuration_info={'issuer': ISSUER},
            client_registration_info={
                'client_id': 'foo',
                'session_refresh_interval_seconds': 300
            },
        )
        client_mock = MagicMock()
        callback_mock = MagicMock()
        callback_mock.__name__ = 'test_callback'  # required for Python 2
        authn.client = client_mock
        id_token = IdToken(**{'sub': 'sub1', 'nonce': 'nonce', 'exp': 0})
        with self.app.test_request_context('/'):
            flask.session['destination'] = '/'

            authn.oidc_auth(callback_mock)()
            session = Session(
                flask_session=flask.session,
                client_registration_info=authn.client_registration_info)

            assert session.authenticated() is False
 def test_reauthenticate_silent_if_refresh_expired(self):
     authn = OIDCAuthentication(
         self.app,
         provider_configuration_info={'issuer': ISSUER},
         client_registration_info={
             'client_id': 'foo',
             'session_refresh_interval_seconds': 1
         },
     )
     client_mock = MagicMock()
     callback_mock = MagicMock()
     callback_mock.__name__ = 'test_callback'  # required for Python 2
     authn.client = client_mock
     id_token = IdToken(**{'sub': 'sub1', 'nonce': 'nonce', 'exp': 0})
     with self.app.test_request_context('/'):
         flask.session['destination'] = '/'
         flask.session['access_token'] = 'test token'
         flask.session['id_token'] = id_token.to_dict()
         flask.session['id_token_jwt'] = id_token.to_jwt()
         flask.session['last_authenticated'] = 1
         authn.oidc_auth(callback_mock)()
     assert client_mock.construct_AuthorizationRequest.called is True
     assert callback_mock.called is False
    def test_should_register_client_if_not_registered_before(self):
        registration_endpoint = self.PROVIDER_BASEURL + '/register'
        provider_metadata = ProviderMetadata(
            self.PROVIDER_BASEURL,
            self.PROVIDER_BASEURL + '/auth',
            self.PROVIDER_BASEURL + '/jwks',
            registration_endpoint=registration_endpoint)
        provider_configurations = {
            self.PROVIDER_NAME:
            ProviderConfiguration(
                provider_metadata=provider_metadata,
                client_registration_info=ClientRegistrationInfo())
        }
        authn = OIDCAuthentication(provider_configurations)
        authn.init_app(self.app)

        # register logout view to force 'post_logout_redirect_uris' to be included in registration request
        logout_view_mock = self.get_view_mock()
        self.app.add_url_rule('/logout', view_func=logout_view_mock)
        authn.oidc_logout(logout_view_mock)

        responses.add(responses.POST,
                      registration_endpoint,
                      json={
                          'client_id': 'client1',
                          'client_secret': 'secret1'
                      })
        view_mock = self.get_view_mock()
        with self.app.test_request_context('/'):
            auth_redirect = authn.oidc_auth(self.PROVIDER_NAME)(view_mock)()

        self.assert_auth_redirect(auth_redirect)
        registration_request = json.loads(
            responses.calls[0].request.body.decode('utf-8'))
        expected_registration_request = {
            'redirect_uris':
            ['http://{}/redirect_uri'.format(self.CLIENT_DOMAIN)],
            'post_logout_redirect_uris':
            ['http://{}/logout'.format(self.CLIENT_DOMAIN)]
        }
        assert registration_request == expected_registration_request