commands.ts

/*
 * Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
 * Ministerpräsidenten des Landes Schleswig-Holstein
 * Staatskanzlei
 * Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
 *
 * Lizenziert unter der EUPL, Version 1.2 oder - sobald
 * diese von der Europäischen Kommission genehmigt wurden -
 * Folgeversionen der EUPL ("Lizenz");
 * Sie dürfen dieses Werk ausschließlich gemäß
 * dieser Lizenz nutzen.
 * Eine Kopie der Lizenz finden Sie hier:
 *
 * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
 *
 * Sofern nicht durch anwendbare Rechtsvorschriften
 * gefordert oder in schriftlicher Form vereinbart, wird
 * die unter der Lizenz verbreitete Software "so wie sie
 * ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
 * ausdrücklich oder stillschweigend - verbreitet.
 * Die sprachspezifischen Genehmigungen und Beschränkungen
 * unter der Lizenz sind dem Lizenztext zu entnehmen.
 */
enum HttpMethod {
  POST = 'POST',
  GET = 'GET',
}

interface HttpHeader {
  [headerKey: string]: string;
}

const DATA_TEST_ID: string = 'data-test-id';
const DATA_TEST_CLASS: string = 'data-test-class';

const ACCES_TOKEN: string = 'access_token';
const ID_TOKEN: string = 'id_token';

enum Header {
  CONTENT_TYPE = 'Content-Type',
  AUTHORIZATION = 'Authorization',
}

const CYPRESS_CONFIG_BASE_URL: unknown = 'baseUrl';

enum CypressEnv {
  KEYCLOAK_CLIENT = 'keycloakClient',
  KEYCLOAK_REALM = 'keycloakRealm',
  KEYCLOAK_URL = 'keycloakUrl',
  SEARCH = 'search',
  SMOCKER = 'smocker',
}

const CONTENT_TYPE_HEADER_VALUE: string = 'application/x-www-form-urlencoded';

interface SearchIndex {
  vorgangId: string;
  vorgangName: string;
  vorgangNummer: string;
  createdAt: string;
  antragstellerName: string;
  antragstellerVorname: string;
  status: string;
  organisationseinheitenId: string;
  aktenzeichen: string;
  assignedTo: string;
  _class: string;
}

const SEARCH_INDEX_CLASS: string = 'de.ozgcloud.vorgang.common.search.IndexedVorgang';

declare namespace Cypress {
  interface Chainable<Subject> {
    getTestElementWithOid(oid: string, ...args);
    getTestElement(selector: string, ...args);
    getTestElementWithClass(selector: string, ...args);
    findTestElementWithClass(selector: string, ...args);
    findElement(selector: string);
    login(user, password);
    logout();
    getUserInfo();
    addVorgangToSearchIndex(vorgang);
    removeAllDocumentsFromSearchIndex();
    addMockToSmocker(mock);
    resetSmocker();
  }
}

Cypress.Commands.add('getTestElement', (selector, ...args) => {
  return cy.get(`[${DATA_TEST_ID}~="${selector}"]`, ...args);
});

Cypress.Commands.add('getTestElementWithClass', (selector, ...args) => {
  return cy.get(`[${DATA_TEST_CLASS}="${selector}"]`, ...args);
});

Cypress.Commands.add('getTestElementWithOid', (oid, ...args) => {
  return cy.getTestElement(oid, ...args);
});

Cypress.Commands.add(
  'findTestElementWithClass',
  { prevSubject: true },
  (subject: any, selector) => {
    return subject.find(`[${DATA_TEST_CLASS}="${selector}"]`);
  },
);

Cypress.Commands.add('findElement', { prevSubject: true }, (subject: any, selector) => {
  return subject.find(selector);
});

Cypress.Commands.add('login', (user: string, password: string) => {
  cy.session(user, () => {
    cy.request(buildLoginRequest(user, password)).then((response) => handleLoginResponse(response));
  });
});

function buildLoginRequest(user: string, password: string): any {
  return {
    method: HttpMethod.POST,
    followRedirect: false,
    url: `${getKeycloakBaseRealmUrl()}/token`,
    headers: {
      [Header.CONTENT_TYPE]: CONTENT_TYPE_HEADER_VALUE,
    },
    body: buildLoginRequestBody(user, password),
  };
}

function buildLoginRequestBody(user: string, password: string): any {
  return {
    client_id: Cypress.env(CypressEnv.KEYCLOAK_CLIENT),
    username: user,
    password: password,
    grant_type: 'password',
    redirect_uri: Cypress.config(CYPRESS_CONFIG_BASE_URL),
    response_mode: 'fragment',
    response_type: 'code',
    scope: 'openid',
  };
}

function handleLoginResponse(response): void {
  const authorization: any = `bearer ${response.body.access_token}`;
  cy.visit('', authorization);

  window.sessionStorage.setItem(ACCES_TOKEN, response.body.access_token);
  window.sessionStorage.setItem(ID_TOKEN, response.body.id_token);

  cy.setCookie('XSRF-TOKEN', response.body.session_state);
}

Cypress.Commands.add('getUserInfo', () => {
  return cy.request({
    method: HttpMethod.GET,
    url: `${getKeycloakBaseRealmUrl()}/userinfo`,
    headers: {
      [Header.AUTHORIZATION]: `bearer ${window.sessionStorage.getItem(ACCES_TOKEN)}`,
    },
  });
});

Cypress.Commands.add('logout', () => {
  cy.request({
    method: HttpMethod.GET,
    url: `${getKeycloakBaseRealmUrl()}/logout`,
    headers: {
      [Header.CONTENT_TYPE]: CONTENT_TYPE_HEADER_VALUE,
    },
    body: {
      refresh_token: window.sessionStorage.getItem(ID_TOKEN),
    },
    failOnStatusCode: false,
  }).then(() => {
    window.sessionStorage.clear();

    cy.visit('');
  });
});

function getKeycloakBaseRealmUrl(): string {
  return `${Cypress.env(CypressEnv.KEYCLOAK_URL)}realms/${Cypress.env(CypressEnv.KEYCLOAK_REALM)}/protocol/openid-connect`;
}

Cypress.Commands.add('addVorgangToSearchIndex', (vorgang) => {
  cy.request({
    method: HttpMethod.POST,
    url: `${buildSearchIndexPostUrl()}/_doc/${vorgang._id.$oid}`,
    headers: buildAuthorizationHeader(),
    body: buildSearchIndexBody(vorgang),
  });
});

function buildSearchIndexBody(vorgang: any): SearchIndex {
  return {
    vorgangId: vorgang._id.$oid,
    vorgangName: vorgang.name,
    vorgangNummer: vorgang.nummer,
    createdAt: vorgang.createdAt.$date,
    antragstellerName: vorgang.eingangs[0].antragsteller.nachname,
    antragstellerVorname: vorgang.eingangs[0].antragsteller.vorname,
    status: vorgang.status,
    organisationseinheitenId: vorgang.eingangs[0].zustaendigeStelle.organisationseinheitenId,
    aktenzeichen: vorgang.aktenzeichen,
    assignedTo: vorgang.assignedTo,
    _class: SEARCH_INDEX_CLASS,
  };
}

Cypress.Commands.add('removeAllDocumentsFromSearchIndex', () => {
  cy.request({
    method: HttpMethod.POST,
    url: `${buildSearchIndexPostUrl()}/_delete_by_query`,
    headers: buildAuthorizationHeader(),
    body: buildSearchIndexRemoveAllBody(),
  });
});

function buildSearchIndexPostUrl(): string {
  const searchEnv: string = getSearchEnv();
  return `${searchEnv['url']}/${searchEnv['index']}`;
}

function buildAuthorizationHeader(): HttpHeader {
  return { [Header.AUTHORIZATION]: `Basic ${buildToken()}` };
}

function buildToken(): string {
  const searchEnv: string = getSearchEnv();
  return btoa(`${searchEnv['user']}:${searchEnv['password']}`);
}

function getSearchEnv(): string {
  return Cypress.env(CypressEnv.SEARCH);
}

function buildSearchIndexRemoveAllBody(): any {
  return {
    query: {
      match_all: {},
    },
  };
}

Cypress.Commands.add('addMockToSmocker', (mock) => {
  cy.fixture(`smocker/${mock}`).then((mockFile) => {
    cy.request({
      method: HttpMethod.POST,
      url: `${getSmockerUrl()}/mocks`,
      body: mockFile,
      headers: {
        "Content-Type": "application/x-yaml"
      }
    });
  });
});

Cypress.Commands.add('resetSmocker', () => {
  cy.request({
    method: HttpMethod.POST,
    url: `${getSmockerUrl()}/reset`,
  });
});

function getSmockerUrl(): string {
  const smockerEnv: string = getSmockerEnv();
  return smockerEnv['url'];
}

function getSmockerEnv(): string {
  return Cypress.env(CypressEnv.SMOCKER);
}