handle ftConnect in AfterOauthSuccess use case

Author: tpicaud

back/src/adapters/primary/routers/auth/auth.e2e.test.ts

@@ -16,7 +16,9 @@ import {
   expectEmailOfType,
   expectHttpResponseToEqual,
   expectToEqual,
+  FTConnectError,
   frontRoutes,
+  ManagedFTConnectError,
   noAgencyDashboards,
   noEstablishmentDashboard,
   queryParamsAsString,
@@ -62,6 +64,7 @@ import { processEventsForEmailToBeSent } from "../../../../utils/processEventsFo
 
 describe("auth router", () => {
   const immersionDomain = "immersion.fr";
+  const now = new Date();
 
   let authRoutesClient: HttpClient<AuthRoutes>;
   let technicalRoutesClient: HttpClient<TechnicalRoutes>;
@@ -99,7 +102,7 @@ describe("auth router", () => {
       technicalRoutes,
       request,
     );
-    gateways.timeGateway.setNextDate(new Date());
+    gateways.timeGateway.setNextDate(now);
   });
 
   describe("user connexion flow", () => {
@@ -148,6 +151,7 @@ describe("auth router", () => {
           );
 
           gateways.proConnectOAuthGateway.setAccessTokenResponse({
+            type: "proConnect",
             accessToken: proConnectToken,
             idToken,
             expire: 1,
@@ -247,6 +251,7 @@ describe("auth router", () => {
         inMemoryUow.agencyRepository.agencies = [toAgencyWithRights(agency)];
 
         gateways.proConnectOAuthGateway.setAccessTokenResponse({
+          type: "proConnect",
           accessToken: proConnectToken,
           expire: 1,
           idToken,
@@ -404,6 +409,208 @@ describe("auth router", () => {
       });
     });
 
+    describe("Right path with FT Connect", () => {
+      const ftConnectAuthCode = "ft-connect-auth-code";
+      const ftConnectAccessToken = "ft-connect-token";
+      const ftConnectIdToken = "ft-connect-id-token";
+      const ftConnectExternalId = "ft-connect-external-id";
+      const conventionDraftId = "ft-connect-convention-draft-id";
+
+      describe(displayRouteName(authRoutes.initiateLoginByOAuth), () => {
+        it("redirects to FT Connect login and stores ongoing OAuth", async () => {
+          const uuids = [nonce, state];
+          uuidGenerator.new = () => uuids.shift() ?? "no-uuid-provided";
+
+          expectHttpResponseToEqual(
+            await authRoutesClient.initiateLoginByOAuth({
+              queryParams: {
+                provider: "peConnect",
+                redirectUri: `/${frontRoutes.conventionImmersionRoute}`,
+              },
+            }),
+            {
+              body: {},
+              status: 302,
+              headers: {
+                location: encodeURI(
+                  `https://fake-ft-connect-login-url?${queryParamsAsString({
+                    nonce,
+                    state,
+                  })}`,
+                ),
+              },
+            },
+          );
+
+          expectToEqual(inMemoryUow.ongoingOAuthRepository.ongoingOAuths, [
+            {
+              provider: "peConnect",
+              nonce,
+              state,
+              usedAt: null,
+              fromUri: `/${frontRoutes.conventionImmersionRoute}`,
+            },
+          ]);
+        });
+      });
+
+      describe(displayRouteName(authRoutes.afterFTConnectOAuthLogin), () => {
+        it("redirects to convention immersion page with convention draft id", async () => {
+          uuidGenerator.new = () => conventionDraftId;
+          inMemoryUow.ongoingOAuthRepository.ongoingOAuths = [
+            {
+              provider: "peConnect",
+              nonce,
+              state,
+              usedAt: null,
+              fromUri: `/${frontRoutes.conventionImmersionRoute}`,
+            },
+          ];
+          gateways.ftConnectGateway.setAccessTokenResult({
+            type: "ftConnect",
+            accessToken: ftConnectAccessToken,
+            expire: 1,
+            idToken: ftConnectIdToken,
+            payload: { nonce },
+          });
+          gateways.ftConnectGateway.setUser({
+            isJobseeker: true,
+            firstName: "Jean",
+            lastName: "Dupont",
+            birthdate: "1990-01-01",
+            peExternalId: ftConnectExternalId,
+          });
+          gateways.ftConnectGateway.setAdvisors([
+            {
+              type: "PLACEMENT",
+              firstName: "Alice",
+              lastName: "Martin",
+              email: "conseiller@francetravail.fr",
+            },
+          ]);
+
+          const response = await authRoutesClient.afterFTConnectOAuthLogin({
+            queryParams: {
+              code: ftConnectAuthCode,
+              state,
+            },
+          });
+
+          expectHttpResponseToEqual(response, {
+            body: {},
+            status: 302,
+            headers: {
+              location: `${appConfig.immersionFacileBaseUrl}/${frontRoutes.conventionImmersionRoute}?conventionDraftId=${conventionDraftId}`,
+            },
+          });
+
+          expectToEqual(inMemoryUow.ongoingOAuthRepository.ongoingOAuths, [
+            {
+              provider: "peConnect",
+              nonce,
+              state,
+              usedAt: now,
+              accessToken: ftConnectAccessToken,
+              fromUri: `/${frontRoutes.conventionImmersionRoute}`,
+            },
+          ]);
+          expectToEqual(
+            inMemoryUow.conventionDraftRepository.conventionDrafts,
+            [
+              {
+                id: conventionDraftId,
+                internshipKind: "immersion",
+                fromPeConnectedUser: true,
+                updatedAt: gateways.timeGateway.now().toISOString(),
+                signatories: {
+                  beneficiary: {
+                    firstName: "Jean",
+                    lastName: "Dupont",
+                    birthdate: "1990-01-01",
+                    federatedIdentity: {
+                      provider: "peConnect",
+                      token: ftConnectExternalId,
+                    },
+                  },
+                },
+                validators: {
+                  agencyCounsellor: {
+                    firstname: "Alice",
+                    lastname: "Martin",
+                  },
+                },
+              },
+            ],
+          );
+        });
+
+        it("redirects to managed FT Connect error page when FT Connect throws a managed error", async () => {
+          inMemoryUow.ongoingOAuthRepository.ongoingOAuths = [
+            {
+              provider: "peConnect",
+              nonce,
+              state,
+              usedAt: null,
+              fromUri: `/${frontRoutes.conventionImmersionRoute}`,
+            },
+          ];
+          gateways.ftConnectGateway.getAccessToken = async () => {
+            throw new ManagedFTConnectError("peConnectNoAuthorisation");
+          };
+
+          const response = await authRoutesClient.afterFTConnectOAuthLogin({
+            queryParams: {
+              code: ftConnectAuthCode,
+              state,
+            },
+          });
+
+          expectHttpResponseToEqual(response, {
+            body: {},
+            status: 302,
+            headers: {
+              location: `${appConfig.immersionFacileBaseUrl}/${frontRoutes.error}?kind=peConnectNoAuthorisation`,
+            },
+          });
+        });
+
+        it("redirects to raw FT Connect error page when FT Connect throws a raw error", async () => {
+          const rawErrorTitle = "Erreur France Travail";
+          const rawErrorMessage = "Le service France Travail est indisponible";
+          inMemoryUow.ongoingOAuthRepository.ongoingOAuths = [
+            {
+              provider: "peConnect",
+              nonce,
+              state,
+              usedAt: null,
+              fromUri: `/${frontRoutes.conventionImmersionRoute}`,
+            },
+          ];
+          gateways.ftConnectGateway.getAccessToken = async () => {
+            throw new FTConnectError(rawErrorTitle, rawErrorMessage);
+          };
+
+          const response = await authRoutesClient.afterFTConnectOAuthLogin({
+            queryParams: {
+              code: ftConnectAuthCode,
+              state,
+            },
+          });
+
+          const { params } = decodeURIWithParams(
+            response.headers.location as string,
+          );
+          expect(response.headers.location).toContain(
+            `${appConfig.immersionFacileBaseUrl}/${frontRoutes.error}`,
+          );
+          expectToEqual(params, {
+            title: encodeURIComponent(rawErrorTitle),
+            message: encodeURIComponent(rawErrorMessage),
+          });
+        });
+      });
+    });
+
     describe(`${displayRouteName(
       authRoutes.getOAuthLogoutUrl,
     )} returns the logout url`, () => {

back/src/adapters/primary/routers/auth/createAuthRouter.ts

@@ -1,8 +1,9 @@
 import type { NextFunction, Request, Response } from "express";
 import { Router } from "express";
-import { authRoutes } from "shared";
+import { authRoutes, FTConnectError, ManagedFTConnectError } from "shared";
 import { createExpressSharedRouter } from "shared-routes/express";
 import type { AppDependencies } from "../../../../config/bootstrap/createAppDependencies";
+import { handleHttpJsonResponseError } from "../../../../config/helpers/handleHttpJsonResponseError";
 import { sendHttpResponse } from "../../../../config/helpers/sendHttpResponse";
 import { sendRedirectResponse } from "../../../../config/helpers/sendRedirectResponse";
 import { getGenericAuthOrThrow } from "../../../../domains/core/authentication/connected-user/entities/user.helper";
@@ -25,10 +26,33 @@ export const createAuthRouter = (deps: AppDependencies) => {
       if (useCaseResult.provider === "proConnect") {
         return res.status(302).redirect(useCaseResult.redirectUri);
       }
+      if (useCaseResult.provider === "peConnect") {
+        throw new Error("Incorrect provider for this route"); //TODO
+      }
       return useCaseResult;
     });
   });
 
+  authSharedRouter.afterFTConnectOAuthLogin(async (req, res) => {
+    try {
+      const useCaseResult =
+        await deps.useCases.afterOAuthSuccessRedirection.execute(req.query);
+      if (useCaseResult.provider !== "peConnect") {
+        throw new Error("Incorrect provider for this route"); //TODO
+      }
+      return res.status(302).redirect(useCaseResult.redirectUri);
+    } catch (error) {
+      if (error instanceof ManagedFTConnectError)
+        return deps.errorHandlers.handleManagedRedirectResponseError(
+          error,
+          res,
+        );
+      if (error instanceof FTConnectError)
+        return deps.errorHandlers.handleRawRedirectResponseError(error, res);
+      return handleHttpJsonResponseError(req, res, error);
+    }
+  });
+
   authSharedRouter.initiateLoginByEmail((req, res) =>
     sendHttpResponse(req, res, () =>
       deps.useCases.initiateLoginByEmail.execute(req.body),

back/src/adapters/primary/routers/ftConnect/createFtConnectRouter.ts

@@ -11,7 +11,6 @@ import { addressesExternalRoutes } from "../../domains/core/address/adapters/Htt
 import { InMemoryAddressGateway } from "../../domains/core/address/adapters/InMemoryAddressGateway";
 import { HttpSubscribersGateway } from "../../domains/core/api-consumer/adapters/HttpSubscribersGateway";
 import { InMemorySubscribersGateway } from "../../domains/core/api-consumer/adapters/InMemorySubscribersGateway";
-import { FtConnectOAuthGateway } from "../../domains/core/authentication/connected-user/adapters/oauth-gateway/FtConnectOAuthGateway";
 import { InMemoryOAuthGateway } from "../../domains/core/authentication/connected-user/adapters/oauth-gateway/InMemoryOAuthGateway";
 import { ProConnectOAuthGateway } from "../../domains/core/authentication/connected-user/adapters/oauth-gateway/ProConnectOAuthGateway";
 import { makeProConnectRoutes } from "../../domains/core/authentication/connected-user/adapters/oauth-gateway/proConnect.routes";
@@ -186,12 +185,7 @@ export const createGateways = async (
             }),
             axiosInstance: axiosWithoutValidateStatus,
           }),
-          {
-            immersionFacileBaseUrl: config.immersionFacileBaseUrl,
-            franceTravailClientId: config.franceTravailClientId,
-            franceTravailClientSecret: config.franceTravailClientSecret,
-            ftAuthCandidatUrl: config.ftAuthCandidatUrl,
-          },
+          config.ftConnectConfig,
           config.ftConnectMaxRequestsPerInterval,
         )
       : new InMemoryFtConnectGateway();
@@ -210,11 +204,6 @@ export const createGateways = async (
         )
       : new InMemoryOAuthGateway(config.proConnectConfig);
 
-  const ftConnectOAuthGateway: OAuthGateway =
-    config.ftConnectGateway === "HTTPS"
-      ? new FtConnectOAuthGateway(config.ftConnectConfig)
-      : new InMemoryOAuthGateway(config.ftConnectConfig);
-
   const createEmailValidationGateway = (config: AppConfig) =>
     ({
       IN_MEMORY: () => new InMemoryEmailValidationGateway(),
@@ -398,7 +387,6 @@ export const createGateways = async (
     emailValidationGateway: createEmailValidationGateway(config),
 
     proConnectOAuthGateway,
-    ftConnectOAuthGateway,
     laBonneBoiteGateway:
       config.laBonneBoiteGateway === "HTTPS"
         ? new HttpLaBonneBoiteGateway(