diff --git a/web/frontend/src/pages/form/components/AddVotersModal.tsx b/web/frontend/src/pages/form/components/AddVotersModal.tsx
index d54113f3f..4a619940f 100644
--- a/web/frontend/src/pages/form/components/AddVotersModal.tsx
+++ b/web/frontend/src/pages/form/components/AddVotersModal.tsx
@@ -169,6 +169,7 @@ export const AddVotersModal: FC<AddVotersModalProps> = ({
               </div>
               <div className="bg-gray-50 px-4 py-3 sm:px-6 sm:flex sm:flex-row-reverse">
                 <button
+                  data-testid="addVotersConfirm"
                   type="button"
                   className="w-full inline-flex justify-center rounded-md border border-transparent shadow-sm px-4 py-2 bg-indigo-600 text-base font-medium text-white hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 sm:ml-3 sm:w-auto sm:text-sm"
                   onClick={confirmChoice}>
diff --git a/web/frontend/src/pages/form/components/ChooseProxyModal.tsx b/web/frontend/src/pages/form/components/ChooseProxyModal.tsx
index fe3bcc6c5..3fe98adb4 100644
--- a/web/frontend/src/pages/form/components/ChooseProxyModal.tsx
+++ b/web/frontend/src/pages/form/components/ChooseProxyModal.tsx
@@ -108,7 +108,9 @@ const ChooseProxyModal: FC<ChooseProxyModalProps> = ({
                   <div className="mx-auto flex-shrink-0 flex items-center justify-center h-12 w-12 rounded-full bg-indigo-100 sm:mx-0 sm:h-10 sm:w-10">
                     <CogIcon className="h-6 w-6 text-indigo-600" aria-hidden="true" />
                   </div>
-                  <div className="mt-3 text-center sm:mt-0 sm:ml-4 sm:text-left">
+                  <div
+                    data-testid="nodeSetup"
+                    className="mt-3 text-center sm:mt-0 sm:ml-4 sm:text-left">
                     <Dialog.Title as="h3" className="text-lg leading-6 font-medium text-gray-900">
                       {t('nodeSetup')}
                     </Dialog.Title>
diff --git a/web/frontend/tests/forms.spec.ts b/web/frontend/tests/forms.spec.ts
index 3648a74ef..f69916b8c 100644
--- a/web/frontend/tests/forms.spec.ts
+++ b/web/frontend/tests/forms.spec.ts
@@ -4,14 +4,35 @@ import { assertHasFooter, assertHasNavBar, initI18n, logIn, setUp } from './shar
 import {
   SCIPER_ADMIN,
   SCIPER_OTHER_ADMIN,
+  SCIPER_OTHER_USER,
   SCIPER_USER,
+  mockDKGActors as mockAPIDKGActors,
+  mockAddRole,
+  mockDKGActorsFormID,
+  mockForms,
   mockPersonalInfo,
   mockProxies,
+  mockServicesShuffle,
 } from './mocks/api';
-import { FORMID, mockDKGActors, mockFormsFormID } from './mocks/evoting';
+import { mockDKGActors, mockFormsFormID } from './mocks/evoting';
+import { FORMID } from './mocks/shared';
+import Worker0 from './json/api/proxies/dela-worker-0.json';
+import Worker1 from './json/api/proxies/dela-worker-1.json';
+import Worker2 from './json/api/proxies/dela-worker-2.json';
+import Worker3 from './json/api/proxies/dela-worker-3.json';
 
 initI18n();
 
+const prettyFormStates = [
+  'Initial',
+  'Open',
+  'Closed',
+  'ShuffledBallots',
+  'PubSharesSubmitted',
+  'ResultAvailable',
+  'Canceled',
+];
+
 // main elements
 
 async function setUpMocks(
@@ -27,7 +48,11 @@ async function setUpMocks(
     await mockProxies(page, i);
   }
   await mockDKGActors(page, dkgActorsStatus, initialized);
+  await mockAPIDKGActors(page);
   await mockPersonalInfo(page);
+  await mockDKGActorsFormID(page);
+  await mockServicesShuffle(page);
+  await mockForms(page);
 }
 
 test.beforeEach(async ({ page }) => {
@@ -62,96 +87,338 @@ async function assertIsOnlyVisibleToOwner(page: page, locator: locator) {
   });
 }
 
-async function assertIsOnlyVisibleToOwnerStates(
+async function assertIsOnlyVisibleInStates(
   page: page,
   locator: locator,
   states: Array,
+  assert: Function,
   dkgActorsStatus?: number,
   initialized?: boolean
 ) {
   for (const i of states) {
-    await test.step(`Assert is only visible to owner in state ${i}`, async () => {
+    await test.step(`Assert is visible in form state '${prettyFormStates.at(i)}'`, async () => {
+      await setUpMocks(page, i, dkgActorsStatus === undefined ? 6 : dkgActorsStatus, initialized);
+      await page.reload({ waitUntil: 'networkidle' });
+      await assert(page, locator);
+    });
+  }
+  for (const i of [0, 1, 2, 3, 4, 5].filter((x) => !states.includes(x))) {
+    await test.step(`Assert is not visible in form state '${prettyFormStates.at(i)}'`, async () => {
       await setUpMocks(page, i, dkgActorsStatus === undefined ? 6 : dkgActorsStatus, initialized);
       await page.reload({ waitUntil: 'networkidle' });
-      await assertIsOnlyVisibleToOwner(page, locator);
+      await expect(locator).toBeHidden();
     });
   }
 }
 
+async function assertRouteIsCalled(
+  page: page,
+  url: string,
+  key: string,
+  action: string,
+  formStatus: number,
+  confirmation: boolean,
+  dkgActorsStatus?: number,
+  initialized?: boolean
+) {
+  await setUpMocks(
+    page,
+    formStatus,
+    dkgActorsStatus === undefined ? 6 : dkgActorsStatus,
+    initialized
+  );
+  await logIn(page, SCIPER_OTHER_ADMIN);
+  page.waitForRequest(async (request) => {
+    const body = await request.postDataJSON();
+    return request.url() === url && request.method() === 'PUT' && body.Action === action;
+  });
+  await page.getByRole('button', { name: i18n.t(key) }).click();
+  if (confirmation) {
+    await page.getByRole('button', { name: i18n.t('yes') }).click();
+  }
+}
+
 test('Assert "Add voters" button is only visible to owner', async ({ page }) => {
-  await assertIsOnlyVisibleToOwnerStates(page, page.getByTestId('addVotersButton'), [0, 1]);
+  await assertIsOnlyVisibleInStates(
+    page,
+    page.getByTestId('addVotersButton'),
+    [0, 1],
+    assertIsOnlyVisibleToOwner
+  );
+});
+
+test('Assert "Add voters" button allows to add voters', async ({ page, baseURL }) => {
+  await setUpMocks(page, 0, 6);
+  await mockAddRole(page);
+  await logIn(page, SCIPER_OTHER_ADMIN);
+  // we expect one call per new voter
+  for (const sciper of [SCIPER_OTHER_ADMIN, SCIPER_ADMIN, SCIPER_USER]) {
+    page.waitForRequest(async (request) => {
+      const body = await request.postDataJSON();
+      return (
+        request.url() === `${baseURL}/api/add_role` &&
+        request.method() === 'POST' &&
+        body.permission === 'vote' &&
+        body.subject === FORMID &&
+        body.userId.toString() === sciper
+      );
+    });
+  }
+  await page.getByTestId('addVotersButton').click();
+  // menu should be visible
+  const textbox = await page.getByRole('textbox', { name: 'SCIPERs' });
+  await expect(textbox).toBeVisible();
+  // add 3 voters (owner admin, non-owner admin, user)
+  await textbox.fill(`${SCIPER_OTHER_ADMIN}\n${SCIPER_ADMIN}\n${SCIPER_USER}`);
+  // click on confirmation
+  await page.getByTestId('addVotersConfirm').click();
 });
 
 test('Assert "Initialize" button is only visible to owner', async ({ page }) => {
-  await assertIsOnlyVisibleToOwnerStates(
+  await assertIsOnlyVisibleInStates(
     page,
     page.getByRole('button', { name: i18n.t('initialize') }),
     [0],
+    assertIsOnlyVisibleToOwner,
     0,
     false
   );
 });
 
+test('Assert "Initialize" button calls route to initialize nodes', async ({ page, baseURL }) => {
+  await setUpMocks(page, 0, 0, false);
+  await logIn(page, SCIPER_OTHER_ADMIN);
+  // we expect one call per worker node
+  for (const worker of [Worker0, Worker1, Worker2, Worker3]) {
+    page.waitForRequest(async (request) => {
+      const body = await request.postDataJSON();
+      return (
+        request.url() === `${baseURL}/api/evoting/services/dkg/actors` &&
+        request.method() === 'POST' &&
+        body.FormID === FORMID &&
+        body.Proxy === worker.Proxy
+      );
+    });
+  }
+  await page.getByRole('button', { name: i18n.t('initialize') }).click();
+});
+
 test('Assert "Setup" button is only visible to owner', async ({ page }) => {
-  await assertIsOnlyVisibleToOwnerStates(
+  await assertIsOnlyVisibleInStates(
     page,
     page.getByRole('button', { name: i18n.t('setup') }),
     [0],
+    assertIsOnlyVisibleToOwner,
     0,
     true
   );
 });
 
+test('Assert "Setup" button calls route to setup node', async ({ page, baseURL }) => {
+  await setUpMocks(page, 0, 0, true);
+  await logIn(page, SCIPER_OTHER_ADMIN);
+  // we expect one call with the chosen worker node
+  page.waitForRequest(async (request) => {
+    const body = await request.postDataJSON();
+    return (
+      request.url() === `${baseURL}/api/evoting/services/dkg/actors/${FORMID}` &&
+      request.method() === 'PUT' &&
+      body.Action === 'setup' &&
+      body.Proxy === Worker1.Proxy
+    );
+  });
+  // open node selection window
+  await page.getByRole('button', { name: i18n.t('setup') }).click();
+  await expect(page.getByTestId('nodeSetup')).toBeVisible();
+  // choose second worker node
+  await page.getByLabel(Worker1.NodeAddr).check();
+  // confirm
+  await page.getByRole('button', { name: i18n.t('setupNode') }).click();
+});
+
 test('Assert "Open" button is only visible to owner', async ({ page }) => {
-  await assertIsOnlyVisibleToOwnerStates(page, page.getByRole('button', { name: i18n.t('open') }), [
+  await assertIsOnlyVisibleInStates(
+    page,
+    page.getByRole('button', { name: i18n.t('open') }),
+    [0],
+    assertIsOnlyVisibleToOwner
+  );
+});
+
+test('Assert "Open" button calls route to open form', async ({ page, baseURL }) => {
+  await assertRouteIsCalled(
+    page,
+    `${baseURL}/api/evoting/forms/${FORMID}`,
+    'open',
+    'open',
     0,
-  ]);
+    false,
+    6
+  );
 });
 
 test('Assert "Cancel" button is only visible to owner', async ({ page }) => {
-  await assertIsOnlyVisibleToOwnerStates(
+  await assertIsOnlyVisibleInStates(
     page,
     page.getByRole('button', { name: i18n.t('cancel') }),
-    [1]
+    [1],
+    assertIsOnlyVisibleToOwner
+  );
+});
+
+test('Assert "Cancel" button calls route to cancel form', async ({ page, baseURL }) => {
+  await assertRouteIsCalled(
+    page,
+    `${baseURL}/api/evoting/forms/${FORMID}`,
+    'cancel',
+    'cancel',
+    1,
+    true
   );
 });
 
 test('Assert "Close" button is only visible to owner', async ({ page }) => {
-  await assertIsOnlyVisibleToOwnerStates(
+  await assertIsOnlyVisibleInStates(
     page,
     page.getByRole('button', { name: i18n.t('close') }),
-    [1]
+    [1],
+    assertIsOnlyVisibleToOwner
+  );
+});
+
+test('Assert "Close" button calls route to close form', async ({ page, baseURL }) => {
+  await assertRouteIsCalled(
+    page,
+    `${baseURL}/api/evoting/forms/${FORMID}`,
+    'close',
+    'close',
+    1,
+    true
   );
 });
 
 test('Assert "Shuffle" button is only visible to owner', async ({ page }) => {
-  await assertIsOnlyVisibleToOwnerStates(
+  await assertIsOnlyVisibleInStates(
     page,
     page.getByRole('button', { name: i18n.t('shuffle') }),
-    [2]
+    [2],
+    assertIsOnlyVisibleToOwner
+  );
+});
+
+test('Assert "Shuffle" button calls route to shuffle form', async ({ page, baseURL }) => {
+  await assertRouteIsCalled(
+    page,
+    `${baseURL}/api/evoting/services/shuffle/${FORMID}`,
+    'shuffle',
+    'shuffle',
+    2,
+    false
   );
 });
 
 test('Assert "Decrypt" button is only visible to owner', async ({ page }) => {
-  await assertIsOnlyVisibleToOwnerStates(
+  await assertIsOnlyVisibleInStates(
     page,
     page.getByRole('button', { name: i18n.t('decrypt') }),
-    [3]
+    [3],
+    assertIsOnlyVisibleToOwner
+  );
+});
+
+test('Assert "Decrypt" button calls route to decrypt form', async ({ page, baseURL }) => {
+  await assertRouteIsCalled(
+    page,
+    `${baseURL}/api/evoting/services/dkg/actors/${FORMID}`,
+    'decrypt',
+    'computePubshares',
+    3,
+    false
   );
 });
 
 test('Assert "Combine" button is only visible to owner', async ({ page }) => {
-  await assertIsOnlyVisibleToOwnerStates(
+  await assertIsOnlyVisibleInStates(
     page,
     page.getByRole('button', { name: i18n.t('combine') }),
-    [4]
+    [4],
+    assertIsOnlyVisibleToOwner
+  );
+});
+
+test('Assert "Combine" button calls route to combine form', async ({ page, baseURL }) => {
+  await assertRouteIsCalled(
+    page,
+    `${baseURL}/api/evoting/forms/${FORMID}`,
+    'combine',
+    'combineShares',
+    4,
+    false
   );
 });
 
 test('Assert "Delete" button is only visible to owner', async ({ page }) => {
-  await assertIsOnlyVisibleToOwnerStates(
+  test.setTimeout(60000); // Firefox is exceeding the default timeout on this test
+  await assertIsOnlyVisibleInStates(
     page,
     page.getByRole('button', { name: i18n.t('delete') }),
-    [0, 1, 2, 3, 4]
+    [0, 1, 2, 3, 4, 6],
+    assertIsOnlyVisibleToOwner
+  );
+});
+
+test('Assert "Delete" button calls route to delete form', async ({ page, baseURL }) => {
+  for (const i of [0, 1, 2, 3, 4, 6]) {
+    await setUpMocks(page, i, 6);
+    await logIn(page, SCIPER_OTHER_ADMIN);
+    page.waitForRequest(async (request) => {
+      return (
+        request.url() === `${baseURL}/api/evoting/forms/${FORMID}` && request.method() === 'DELETE'
+      );
+    });
+    await page.getByRole('button', { name: i18n.t('delete') }).click();
+    await page.getByRole('button', { name: i18n.t('yes') }).click();
+  }
+});
+
+test('Assert "Vote" button is visible to admin/non-admin voter user', async ({ page }) => {
+  await assertIsOnlyVisibleInStates(
+    page,
+    page.getByRole('button', { name: i18n.t('vote'), exact: true }), // by default name is not matched exactly which returns both the "Vote" and the "Add voters" button
+    [1],
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    async function (page: page, locator: locator) {
+      await test.step('Assert is hidden to unauthenticated user', async () => {
+        await expect(locator).toBeHidden();
+      });
+      await test.step('Assert is hidden to authenticated non-voter user', async () => {
+        await logIn(page, SCIPER_OTHER_USER);
+        await expect(locator).toBeHidden();
+      });
+      await test.step('Assert is visible to authenticated voter user', async () => {
+        await logIn(page, SCIPER_USER);
+        await expect(locator).toBeVisible();
+      });
+      await test.step('Assert is hidden to non-voter admin', async () => {
+        await logIn(page, SCIPER_OTHER_ADMIN);
+        await expect(locator).toBeHidden();
+      });
+      await test.step('Assert is visible to voter admin', async () => {
+        await logIn(page, SCIPER_ADMIN);
+        await expect(locator).toBeVisible();
+      });
+    }
   );
 });
+
+test('Assert "Vote" button gets voting form', async ({ page }) => {
+  await setUpMocks(page, 1, 6);
+  await logIn(page, SCIPER_USER);
+  page.waitForRequest(`${process.env.DELA_PROXY_URL}/evoting/forms/${FORMID}`);
+  await page.getByRole('button', { name: i18n.t('vote') }).click();
+  // go back to form management page
+  await setUp(page, `/forms/${FORMID}`);
+  await logIn(page, SCIPER_ADMIN);
+  page.waitForRequest(`${process.env.DELA_PROXY_URL}/evoting/forms/${FORMID}`);
+  await page.getByRole('button', { name: i18n.t('vote') }).click();
+});
diff --git a/web/frontend/tests/json/api/personal_info/654321.json b/web/frontend/tests/json/api/personal_info/654321.json
new file mode 100644
index 000000000..5650be68f
--- /dev/null
+++ b/web/frontend/tests/json/api/personal_info/654321.json
@@ -0,0 +1,7 @@
+{
+  "sciper": 654321,
+  "lastName": "654321",
+  "firstName": "sciper-#",
+  "isLoggedIn": true,
+  "authorization": {}
+}
diff --git a/web/frontend/tests/json/evoting/dkgActors/uninitialized.json b/web/frontend/tests/json/evoting/dkgActors/uninitialized.json
index 1279f9f3c..355d98ecf 100644
--- a/web/frontend/tests/json/evoting/dkgActors/uninitialized.json
+++ b/web/frontend/tests/json/evoting/dkgActors/uninitialized.json
@@ -5,6 +5,6 @@
   "Args": {
     "error": "actor not found",
     "method": "GET",
-    "url": "/evoting/services/dkg/actors/d3319c58a3bea17dafe61168610757b9a7bb0d922c1f2aa30b8ad537646b1c07"
+    "url": "/evoting/services/dkg/actors/b63bcb854121051f2d8cff04bf0ac9b524b534b704509a16a423448bde3321b4"
   }
 }
diff --git a/web/frontend/tests/json/evoting/forms/canceled.json b/web/frontend/tests/json/evoting/forms/canceled.json
new file mode 100644
index 000000000..908e8885c
--- /dev/null
+++ b/web/frontend/tests/json/evoting/forms/canceled.json
@@ -0,0 +1,64 @@
+{
+  "FormID": "b63bcb854121051f2d8cff04bf0ac9b524b534b704509a16a423448bde3321b4",
+  "Configuration": {
+    "Title": {
+      "En": "Colours",
+      "Fr": "",
+      "De": ""
+    },
+    "Scaffold": [
+      {
+        "ID": "yOakwFnR",
+        "Title": {
+          "En": "Colours",
+          "Fr": "Couleurs",
+          "De": "Farben"
+        },
+        "Order": [
+          "CLgNiLbC"
+        ],
+        "Subjects": [],
+        "Selects": [
+          {
+            "ID": "CLgNiLbC",
+            "Title": {
+              "En": "RGB",
+              "Fr": "RGB",
+              "De": "RGB"
+            },
+            "MaxN": 2,
+            "MinN": 1,
+            "Choices": [
+              "{\"en\":\"Red\",\"fr\":\"Rouge\",\"de\":\"Rot\"}",
+              "{\"en\":\"Green\",\"fr\":\"Vert\",\"de\":\"Grün\"}",
+              "{\"en\":\"Blue\",\"fr\":\"Bleu\",\"de\":\"Blau\"}"
+            ],
+            "Hint": {
+              "En": "",
+              "Fr": "",
+              "De": ""
+            }
+          }
+        ],
+        "Ranks": [],
+        "Texts": []
+      }
+    ]
+  },
+  "Status": 2,
+  "Pubkey": "612fdc867be1a5faccf16e5aed946880005840ee04aaa382fe181a2b46dc9a24",
+  "Result": [],
+  "Roster": [
+    "grpc://dela-worker-0:2000",
+    "grpc://dela-worker-1:2000",
+    "grpc://dela-worker-2:2000",
+    "grpc://dela-worker-3:2000"
+  ],
+  "ChunksPerBallot": 1,
+  "BallotSize": 23,
+  "Voters": [
+    "oUItDdhhEE",
+    "WZyqP1gssL",
+    "K7ZNvumBVc"
+  ]
+}
diff --git a/web/frontend/tests/mocks/api.ts b/web/frontend/tests/mocks/api.ts
index 4d5ec042f..0ce10b83a 100644
--- a/web/frontend/tests/mocks/api.ts
+++ b/web/frontend/tests/mocks/api.ts
@@ -1,6 +1,44 @@
+import { FORMID } from './shared';
 export const SCIPER_ADMIN = '123456';
 export const SCIPER_OTHER_ADMIN = '987654';
 export const SCIPER_USER = '789012';
+export const SCIPER_OTHER_USER = '654321';
+
+// /api/evoting
+
+export async function mockDKGActors(page: page) {
+  await page.route('/api/evoting/services/dkg/actors', async (route) => {
+    if (route.request().method() === 'POST') {
+      await route.fulfill({ status: 200 });
+    }
+  });
+}
+
+export async function mockDKGActorsFormID(page: page) {
+  await page.route(`/api/evoting/services/dkg/actors/${FORMID}`, async (route) => {
+    if (route.request().method() === 'PUT') {
+      await route.fulfill({ status: 200 });
+    }
+  });
+}
+
+export async function mockServicesShuffle(page: page) {
+  await page.route('/api/evoting/services/shuffle/', async (route) => {
+    if (route.request().method() === 'PUT') {
+      await route.fulfill({ status: 200 });
+    }
+  });
+}
+
+export async function mockForms(page: page) {
+  await page.route(`/api/evoting/forms/${FORMID}`, async (route) => {
+    if (route.request().method() === 'PUT') {
+      await route.fulfill({ status: 200 });
+    }
+  });
+}
+
+// /api/config
 
 export async function mockProxy(page: page) {
   await page.route('/api/config/proxy', async (route) => {
@@ -16,6 +54,8 @@ export async function mockProxy(page: page) {
   });
 }
 
+// /api
+
 export async function mockProxies(page: page, workerNumber: number) {
   await page.route(
     `/api/proxies/grpc%3A%2F%2Fdela-worker-${workerNumber}%3A2000`,
@@ -72,3 +112,9 @@ export async function mockLogout(page: page) {
     await route.fulfill({});
   });
 }
+
+export async function mockAddRole(page: page) {
+  await page.route('/api/add_role', async (route) => {
+    await route.fulfill({ status: 200 });
+  });
+}
diff --git a/web/frontend/tests/mocks/evoting.ts b/web/frontend/tests/mocks/evoting.ts
index dfa5784cd..6aa297779 100644
--- a/web/frontend/tests/mocks/evoting.ts
+++ b/web/frontend/tests/mocks/evoting.ts
@@ -2,8 +2,7 @@ import Worker0 from './../json/api/proxies/dela-worker-0.json';
 import Worker1 from './../json/api/proxies/dela-worker-1.json';
 import Worker2 from './../json/api/proxies/dela-worker-2.json';
 import Worker3 from './../json/api/proxies/dela-worker-3.json';
-
-export const FORMID = 'b63bcb854121051f2d8cff04bf0ac9b524b534b704509a16a423448bde3321b4';
+import { FORMID } from './shared';
 
 export async function mockForms(page: page, empty: boolean = true) {
   // clear current mock
@@ -42,6 +41,7 @@ export async function mockFormsFormID(page: page, formStatus: number) {
       'shuffled.json',
       'decrypted.json',
       'combined.json',
+      'canceled.json',
     ][formStatus];
     await route.fulfill({
       path: `./tests/json/evoting/forms/${formFile}`,
diff --git a/web/frontend/tests/mocks/shared.ts b/web/frontend/tests/mocks/shared.ts
new file mode 100644
index 000000000..887386d78
--- /dev/null
+++ b/web/frontend/tests/mocks/shared.ts
@@ -0,0 +1 @@
+export const FORMID = 'b63bcb854121051f2d8cff04bf0ac9b524b534b704509a16a423448bde3321b4';
diff --git a/web/frontend/tests/shared.ts b/web/frontend/tests/shared.ts
index e99e8d7a4..81852c2f3 100644
--- a/web/frontend/tests/shared.ts
+++ b/web/frontend/tests/shared.ts
@@ -12,6 +12,8 @@ import {
   mockProxy,
 } from './mocks/api';
 
+export const FORMID = 'b63bcb854121051f2d8cff04bf0ac9b524b534b704509a16a423448bde3321b4';
+
 export function initI18n() {
   i18n.init({
     resources: { en, fr, de },