chore(e2e): formatting with prettier (#4385)

* prettier in e2e * format * typescript as dev dependency * ci all, check linting * resolve liniting issues * fix wait-on * fix package-lock.json Co-authored-by: Elio Bischof <eliobischof@gmail.com>
2025-08-11 21:37:32 +00:00 · 2022-09-19 19:49:46 +02:00
parent 8505eb4cc9
commit fc4f4096e0
22 changed files with 522 additions and 526 deletions
--- a/e2e/cypress/support/api/apiauth.ts
+++ b/e2e/cypress/support/api/apiauth.ts
@@ -1,15 +1,15 @@
-import { login, User } from 'support/login/users'
+import { login, User } from 'support/login/users';

 export interface apiCallProperties {
-    authHeader: string
-    mgntBaseURL: string
+  authHeader: string;
+  mgntBaseURL: string;
 }

 export function apiAuth(): Cypress.Chainable<apiCallProperties> {
-    return login(User.IAMAdminUser, 'Password1!', false, true).then(token => {
-        return <apiCallProperties>{
-            authHeader: `Bearer ${token}`,
-            mgntBaseURL: `${Cypress.env("BACKEND_URL")}/management/v1/`,
-        }
-    })
+  return login(User.IAMAdminUser, 'Password1!', false, true).then((token) => {
+    return <apiCallProperties>{
+      authHeader: `Bearer ${token}`,
+      mgntBaseURL: `${Cypress.env('BACKEND_URL')}/management/v1/`,
+    };
+  });
 }
--- a/e2e/cypress/support/api/ensure.ts
+++ b/e2e/cypress/support/api/ensure.ts
@@ -1,89 +1,118 @@
-import { apiCallProperties } from "./apiauth"
+import { apiCallProperties } from './apiauth';

-export function ensureSomethingExists(api: apiCallProperties, searchPath: string, find: (entity: any) => boolean, createPath: string, body: any): Cypress.Chainable<number> {
-
-    return searchSomething(api, searchPath, find).then(sRes => {
-        if (sRes.entity) {
-            return cy.wrap({
-                id: sRes.entity.id,
-                initialSequence: 0
-            })
-        }
-        return cy.request({
-            method: 'POST',
-            url: `${api.mgntBaseURL}${createPath}`,
-            headers: {
-                Authorization: api.authHeader
-            },
-            body: body,
-            failOnStatusCode: false,
-            followRedirect: false,
-        }).then(cRes => {
-            expect(cRes.status).to.equal(200)
-            return {
-                id: cRes.body.id,
-                initialSequence: sRes.sequence
-            }
+export function ensureSomethingExists(
+  api: apiCallProperties,
+  searchPath: string,
+  find: (entity: any) => boolean,
+  createPath: string,
+  body: any,
+): Cypress.Chainable<number> {
+  return searchSomething(api, searchPath, find)
+    .then((sRes) => {
+      if (sRes.entity) {
+        return cy.wrap({
+          id: sRes.entity.id,
+          initialSequence: 0,
+        });
+      }
+      return cy
+        .request({
+          method: 'POST',
+          url: `${api.mgntBaseURL}${createPath}`,
+          headers: {
+            Authorization: api.authHeader,
+          },
+          body: body,
+          failOnStatusCode: false,
+          followRedirect: false,
        })
-    }).then((data) => {
-        awaitDesired(90, (entity) => !!entity, data.initialSequence, api, searchPath, find)
-        return cy.wrap<number>(data.id)
+        .then((cRes) => {
+          expect(cRes.status).to.equal(200);
+          return {
+            id: cRes.body.id,
+            initialSequence: sRes.sequence,
+          };
+        });
    })
+    .then((data) => {
+      awaitDesired(90, (entity) => !!entity, data.initialSequence, api, searchPath, find);
+      return cy.wrap<number>(data.id);
+    });
 }

-export function ensureSomethingDoesntExist(api: apiCallProperties, searchPath: string, find: (entity: any) => boolean, deletePath: (entity: any) => string): Cypress.Chainable<null> {
-
-    return searchSomething(api, searchPath, find).then(sRes => {
-        if (!sRes.entity) {
-            return cy.wrap(0)
-        }
-        return cy.request({
-            method: 'DELETE',
-            url: `${api.mgntBaseURL}${deletePath(sRes.entity)}`,
-            headers: {
-                Authorization: api.authHeader
-            },
-            failOnStatusCode: false
-        }).then((dRes) => {
-            expect(dRes.status).to.equal(200)
-            return sRes.sequence
+export function ensureSomethingDoesntExist(
+  api: apiCallProperties,
+  searchPath: string,
+  find: (entity: any) => boolean,
+  deletePath: (entity: any) => string,
+): Cypress.Chainable<null> {
+  return searchSomething(api, searchPath, find)
+    .then((sRes) => {
+      if (!sRes.entity) {
+        return cy.wrap(0);
+      }
+      return cy
+        .request({
+          method: 'DELETE',
+          url: `${api.mgntBaseURL}${deletePath(sRes.entity)}`,
+          headers: {
+            Authorization: api.authHeader,
+          },
+          failOnStatusCode: false,
        })
-    }).then((initialSequence) => {
-        awaitDesired(90, (entity) => !entity , initialSequence, api, searchPath, find)
-        return null
+        .then((dRes) => {
+          expect(dRes.status).to.equal(200);
+          return sRes.sequence;
+        });
    })
+    .then((initialSequence) => {
+      awaitDesired(90, (entity) => !entity, initialSequence, api, searchPath, find);
+      return null;
+    });
 }

 type SearchResult = {
-    entity: any
-    sequence: number
-}
+  entity: any;
+  sequence: number;
+};

-function searchSomething(api: apiCallProperties, searchPath: string, find: (entity: any) => boolean): Cypress.Chainable<SearchResult> {
-
-    return cy.request({
-        method: 'POST',
-        url: `${api.mgntBaseURL}${searchPath}`,
-        headers: {
-            Authorization: api.authHeader
-        },
-    }).then(res => {
-        return {
-            entity: res.body.result?.find(find) || null,
-            sequence: res.body.details.processedSequence
-        }
+function searchSomething(
+  api: apiCallProperties,
+  searchPath: string,
+  find: (entity: any) => boolean,
+): Cypress.Chainable<SearchResult> {
+  return cy
+    .request({
+      method: 'POST',
+      url: `${api.mgntBaseURL}${searchPath}`,
+      headers: {
+        Authorization: api.authHeader,
+      },
    })
+    .then((res) => {
+      return {
+        entity: res.body.result?.find(find) || null,
+        sequence: res.body.details.processedSequence,
+      };
+    });
 }

-function awaitDesired(trials: number, expectEntity: (entity: any) => boolean, initialSequence: number, api: apiCallProperties, searchPath: string, find: (entity: any) => boolean) {
-    searchSomething(api, searchPath, find).then(resp => {
-        const foundExpectedEntity = expectEntity(resp.entity)
-        const foundExpectedSequence = resp.sequence > initialSequence
+function awaitDesired(
+  trials: number,
+  expectEntity: (entity: any) => boolean,
+  initialSequence: number,
+  api: apiCallProperties,
+  searchPath: string,
+  find: (entity: any) => boolean,
+) {
+  searchSomething(api, searchPath, find).then((resp) => {
+    const foundExpectedEntity = expectEntity(resp.entity);
+    const foundExpectedSequence = resp.sequence > initialSequence;

-        if (!foundExpectedEntity || !foundExpectedSequence) {
-            expect(trials, `trying ${trials} more times`).to.be.greaterThan(0);
-            cy.wait(1000)
-            awaitDesired(trials - 1, expectEntity, initialSequence, api, searchPath, find)
-        }
-    })
+    if (!foundExpectedEntity || !foundExpectedSequence) {
+      expect(trials, `trying ${trials} more times`).to.be.greaterThan(0);
+      cy.wait(1000);
+      awaitDesired(trials - 1, expectEntity, initialSequence, api, searchPath, find);
+    }
+  });
 }
--- a/e2e/cypress/support/api/policies.ts
+++ b/e2e/cypress/support/api/policies.ts
@@ -1,19 +1,18 @@
-import { apiCallProperties } from "./apiauth"
-
+import { apiCallProperties } from './apiauth';

 export enum Policy {
-    Label = "label"
+  Label = 'label',
 }

 export function resetPolicy(api: apiCallProperties, policy: Policy) {
-    cy.request({
-        method: 'DELETE',
-        url: `${api.mgntBaseURL}/policies/${policy}`,
-        headers: {
-            Authorization: api.authHeader
-        },
-    }).then(res => {
-        expect(res.status).to.equal(200)
-        return null
-    })    
-}
+  cy.request({
+    method: 'DELETE',
+    url: `${api.mgntBaseURL}/policies/${policy}`,
+    headers: {
+      Authorization: api.authHeader,
+    },
+  }).then((res) => {
+    expect(res.status).to.equal(200);
+    return null;
+  });
+}
--- a/e2e/cypress/support/api/projects.ts
+++ b/e2e/cypress/support/api/projects.ts
@@ -1,80 +1,69 @@
-import { apiCallProperties } from "./apiauth"
-import { ensureSomethingDoesntExist, ensureSomethingExists } from "./ensure"
+import { apiCallProperties } from './apiauth';
+import { ensureSomethingDoesntExist, ensureSomethingExists } from './ensure';

 export function ensureProjectExists(api: apiCallProperties, projectName: string): Cypress.Chainable<number> {
-    
-    return ensureSomethingExists(
-        api,
-        `projects/_search`,
-        (project: any) => project.name === projectName,
-        'projects',
-        { name: projectName },
-    )
+  return ensureSomethingExists(api, `projects/_search`, (project: any) => project.name === projectName, 'projects', {
+    name: projectName,
+  });
 }

 export function ensureProjectDoesntExist(api: apiCallProperties, projectName: string): Cypress.Chainable<null> {
-    
-    return ensureSomethingDoesntExist(
-        api,
-        `projects/_search`,
-        (project: any) => project.name === projectName,
-        (project) => `projects/${project.id}`,
-    )
+  return ensureSomethingDoesntExist(
+    api,
+    `projects/_search`,
+    (project: any) => project.name === projectName,
+    (project) => `projects/${project.id}`,
+  );
 }

 class ResourceType {
-    constructor(
-        public resourcePath: string,
-        public compareProperty: string,
-        public identifierProperty: string,
-    ){}
+  constructor(public resourcePath: string, public compareProperty: string, public identifierProperty: string) {}
 }

-export const Apps = new ResourceType('apps', 'name', 'id')
-export const Roles = new ResourceType('roles', 'key', 'key')
+export const Apps = new ResourceType('apps', 'name', 'id');
+export const Roles = new ResourceType('roles', 'key', 'key');
 //export const Grants = new ResourceType('apps', 'name')

-
-export function ensureProjectResourceDoesntExist(api: apiCallProperties, projectId: number, resourceType: ResourceType, resourceName: string): Cypress.Chainable<null> {
-    return ensureSomethingDoesntExist(
-        api,
-        `projects/${projectId}/${resourceType.resourcePath}/_search`,
-        (resource: any) => {
-            return resource[resourceType.compareProperty] === resourceName
-        },
-        (resource) => {
-            return `projects/${projectId}/${resourceType.resourcePath}/${resource[resourceType.identifierProperty]}`
-        }
-    )
+export function ensureProjectResourceDoesntExist(
+  api: apiCallProperties,
+  projectId: number,
+  resourceType: ResourceType,
+  resourceName: string,
+): Cypress.Chainable<null> {
+  return ensureSomethingDoesntExist(
+    api,
+    `projects/${projectId}/${resourceType.resourcePath}/_search`,
+    (resource: any) => {
+      return resource[resourceType.compareProperty] === resourceName;
+    },
+    (resource) => {
+      return `projects/${projectId}/${resourceType.resourcePath}/${resource[resourceType.identifierProperty]}`;
+    },
+  );
 }

-export function ensureApplicationExists(api: apiCallProperties, projectId: number, appName: string): Cypress.Chainable<number> {
-
-    return ensureSomethingExists(
-        api,
-        `projects/${projectId}/${Apps.resourcePath}/_search`,
-        (resource: any) => resource.name === appName,
-        `projects/${projectId}/${Apps.resourcePath}/oidc`,
-        {
-            name: appName,
-            redirectUris: [
-                'https://e2eredirecturl.org'
-            ],
-            responseTypes: [
-                "OIDC_RESPONSE_TYPE_CODE"
-            ],
-            grantTypes: [
-                "OIDC_GRANT_TYPE_AUTHORIZATION_CODE"
-            ],
-            authMethodType: "OIDC_AUTH_METHOD_TYPE_NONE",
-            postLogoutRedirectUris: [
-                'https://e2elogoutredirecturl.org'
-            ],
-/*            "clientId": "129383004379407963@e2eprojectpermission",
+export function ensureApplicationExists(
+  api: apiCallProperties,
+  projectId: number,
+  appName: string,
+): Cypress.Chainable<number> {
+  return ensureSomethingExists(
+    api,
+    `projects/${projectId}/${Apps.resourcePath}/_search`,
+    (resource: any) => resource.name === appName,
+    `projects/${projectId}/${Apps.resourcePath}/oidc`,
+    {
+      name: appName,
+      redirectUris: ['https://e2eredirecturl.org'],
+      responseTypes: ['OIDC_RESPONSE_TYPE_CODE'],
+      grantTypes: ['OIDC_GRANT_TYPE_AUTHORIZATION_CODE'],
+      authMethodType: 'OIDC_AUTH_METHOD_TYPE_NONE',
+      postLogoutRedirectUris: ['https://e2elogoutredirecturl.org'],
+      /*            "clientId": "129383004379407963@e2eprojectpermission",
            "clockSkew": "0s",
            "allowedOrigins": [
                "https://testurl.org"
            ]*/
-        },
-    )
+    },
+  );
 }
--- a/e2e/cypress/support/api/users.ts
+++ b/e2e/cypress/support/api/users.ts
@@ -1,49 +1,35 @@
-import { apiCallProperties } from "./apiauth"
-import { ensureSomethingDoesntExist, ensureSomethingExists } from "./ensure"
+import { apiCallProperties } from './apiauth';
+import { ensureSomethingDoesntExist, ensureSomethingExists } from './ensure';

 export function ensureHumanUserExists(api: apiCallProperties, username: string): Cypress.Chainable<number> {
-
-    return ensureSomethingExists(
-        api,
-        'users/_search',
-        (user: any) => user.userName === username,
-        'users/human',
-        {
-            user_name: username,
-            profile: {
-                first_name: 'e2efirstName',
-                last_name: 'e2elastName',
-            },
-            email: { 
-                email: 'e2e@email.ch',
-            },
-            phone: {
-                phone: '+41 123456789',
-        },
-    })
+  return ensureSomethingExists(api, 'users/_search', (user: any) => user.userName === username, 'users/human', {
+    user_name: username,
+    profile: {
+      first_name: 'e2efirstName',
+      last_name: 'e2elastName',
+    },
+    email: {
+      email: 'e2e@email.ch',
+    },
+    phone: {
+      phone: '+41 123456789',
+    },
+  });
 }

 export function ensureMachineUserExists(api: apiCallProperties, username: string): Cypress.Chainable<number> {
-    
-    return ensureSomethingExists(
-        api,
-        'users/_search',
-        (user: any) => user.userName === username,
-        'users/machine',
-        {
-            user_name: username,
-            name: 'e2emachinename',
-            description: 'e2emachinedescription',
-        },
-    )
+  return ensureSomethingExists(api, 'users/_search', (user: any) => user.userName === username, 'users/machine', {
+    user_name: username,
+    name: 'e2emachinename',
+    description: 'e2emachinedescription',
+  });
 }

 export function ensureUserDoesntExist(api: apiCallProperties, username: string): Cypress.Chainable<null> {
-
-    return ensureSomethingDoesntExist(
-        api,
-        'users/_search',
-        (user: any) => user.userName === username,
-        (user) => `users/${user.id}`
-    )
+  return ensureSomethingDoesntExist(
+    api,
+    'users/_search',
+    (user: any) => user.userName === username,
+    (user) => `users/${user.id}`,
+  );
 }