it('should return token from cookie', () => {
    const jwtValue = 'a'

    const req = {
      cookies: {
        [sessionCookieName]: jwtValue
      }
    } as Request

    expect(JwtExtractor.extract(req)).to.equal(jwtValue)
  })

async function getAuthToken (req: express.Request,
                             receiver: RoutablePath = AppPaths.receiver,
                             checkCookie = true): Promise<string> {
  let authenticationToken
  if (req.query.code) {
    authenticationToken = await getOAuthAccessToken(req, receiver)
  } else if (checkCookie) {
    authenticationToken = JwtExtractor.extract(req)
  }
  return authenticationToken
}

async function authorizationRequestHandler (req: express.Request, res: express.Response, next: express.NextFunction) {
  const jwt: string = JwtExtractor.extract(req)
  if (jwt) {
    try {
      await IdamClient.retrieveUserFor(jwt)
      res.locals.isLoggedIn = true
    } catch (err) {
      if (!hasTokenExpired(err)) {
        next(err)
        return
      }
    }
  }
  next()
}

    ErrorHandling.apply(async (req: express.Request, res: express.Response, next: express.NextFunction): Promise<void> => {
      const jwt: string = JwtExtractor.extract(req)

      if (jwt) {
        try {
          await IdamClient.invalidateSession(jwt)
        } catch (error) {
          const { id } = JwtUtils.decodePayload(jwt)
          logger.error(`Failed invalidating JWT for userId  ${id}`)
        }

        const cookies = new Cookies(req, res)
        cookies.set(sessionCookie, '')
      }

      res.redirect(Paths.homePage.uri)
    })

    return (req: express.Request, res: express.Response, next: express.NextFunction) => {
      const jwt: string = JwtExtractor.extract(req)

      if (isPathUnprotected(req.path)) {
        logger.debug(`Unprotected path - access to ${req.path} granted`)
        return next()
      }

      if (!jwt) {
        logger.debug(`Protected path - no JWT - access to ${req.path} rejected`)
        return accessDeniedCallback(req, res)
      } else {
        IdamClient
          .retrieveUserFor(jwt)
          .then((user: User) => {
            if (!user.isInRoles(...requiredRoles)) {
              logger.error(`Protected path - valid JWT but user not in ${requiredRoles} roles - redirecting to access denied page`)
              return accessDeniedCallback(req, res)
            } else {
              res.locals.isLoggedIn = true
              res.locals.user = user
              logger.debug(`Protected path - valid JWT & role - access to ${req.path} granted`)
              return next()
            }
          })
          .catch((err) => {
            if (hasTokenExpired(err)) {
              const cookies = new Cookies(req, res)
              cookies.set(sessionCookieName, '')
              logger.debug(`Protected path - invalid JWT - access to ${req.path} rejected`)
              return accessDeniedCallback(req, res)
            }
            return next(err)
          })
      }
    }

function receiverPath (req: express.Request, res: express.Response): string {
  return `${OAuthHelper.forUplift(req, res)}&jwt=${JwtExtractor.extract(req)}`
}

 .get(Paths.startPage.uri, (req: express.Request, res: express.Response): void => {
   res.render(Paths.startPage.associatedView, {
     registeredUser: JwtExtractor.extract(req) !== undefined
   })
 })