cypress-helper.ts

/*
 * Copyright (C) 2023 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.
 */
import { Interception, RouteHandler, RouteMatcher } from 'cypress/types/net-stubbing';
import { CreateFileDataE2E, GridFsChunkE2E, GridFsFileE2E, OzgCloudFileE2E } from '../model/binary-file';
import { CommandE2E } from '../model/command';
import { SmockerMocks } from '../model/smocker';
import { UsermanagerUserE2E } from '../model/usermanager';
import { VorgangE2E } from '../model/vorgang';
import { VorgangAttachedItemE2E } from '../model/vorgang-attached-item';
import { waitForSpinnerToDisappear } from '../page-objects/main.po';

enum CypressTasks {
  DROP_COLLECTIONS = 'dropCollections',
  DROP_USER_MANAGER_COLLECTIONS = 'dropUserManagerCollections',
  INIT_COMMAND_DATA = 'initCommandData',
  INIT_GRID_FS_FILE_DATA = 'initGridFsFileData',
  INIT_GRID_FS_CHUNK_DATA = 'initGridFsChunkData',
  INIT_OZG_CLOUD_FILE = 'initOzgCloudFileData',
  INIT_VORGANG_DATA = 'initVorgangData',
  INIT_VORGANG_ATTACHED_ITEM_DATA = 'initVorgangAttachedItemData',
  INIT_USERMANAGER_DATA = 'initUsermanagerData',
  COUNT_FILES = 'countFiles',
  DELETE_FOLDER = 'deleteFolder',
  UNZIP_FILE = 'unzipDownloadFile',
  GET_DOWNLOAD_FILES = 'getDownloadFiles',
  WRITE_USER_IDS_TO_FILE = 'writeUserIdsToFile',
}

enum MongoCollections {
  COMMAND = 'command',
  FS_CHUNKS = 'fs.chunks',
  FS_FILES = 'fs.files',
  OZG_CLOUD_FILE = 'ozgCloudFile',
  VORGANG = 'vorgang',
  VORGANG_ATTACHED_ITEM = 'vorgangAttachedItem',
  USER = 'User',
}

const DOWNLOAD_FOLDER: string = 'cypress/downloads';

export function login(userJsonPath: string): void {
  cy.fixture(userJsonPath).then((user) => {
    cy.login(user.name, user.password);
  });
  waitForSpinnerToDisappear();
}

export function visitUrl(url: string): void {
  cy.visit(url);
}

export function initCommandData(data: CommandE2E[]): void {
  dropCollection(MongoCollections.COMMAND);
  cy.task(CypressTasks.INIT_COMMAND_DATA, { collection: MongoCollections.COMMAND, data });
}

export function initFileData(data: CreateFileDataE2E[]): void {
  const files: GridFsFileE2E[] = [];
  const ozgCloudFiles: OzgCloudFileE2E[] = [];
  let chunks: GridFsChunkE2E[] = [];

  data.forEach((singleData) => {
    files.push(singleData.file);
    ozgCloudFiles.push(singleData.ozgcloudFile);
    chunks = chunks.concat(singleData.chunks);
  });

  initGridFsFileData(files);
  initGridFsChunkData(chunks);
  initOzgCloudFileData(ozgCloudFiles);
}

function initGridFsFileData(data: GridFsFileE2E[]): void {
  dropCollection(MongoCollections.FS_FILES);
  cy.task(CypressTasks.INIT_GRID_FS_FILE_DATA, { collection: MongoCollections.FS_FILES, data });
}

function initGridFsChunkData(data: GridFsChunkE2E[]): void {
  dropCollection(MongoCollections.FS_CHUNKS);
  cy.task(CypressTasks.INIT_GRID_FS_CHUNK_DATA, { collection: MongoCollections.FS_CHUNKS, data });
}

function initOzgCloudFileData(data: OzgCloudFileE2E[]): void {
  dropCollection(MongoCollections.OZG_CLOUD_FILE);
  cy.task(CypressTasks.INIT_OZG_CLOUD_FILE, { collection: MongoCollections.OZG_CLOUD_FILE, data });
}

export function initVorgangAttachedItemData(data: VorgangAttachedItemE2E[]): void {
  dropCollection(MongoCollections.VORGANG_ATTACHED_ITEM);
  cy.task(CypressTasks.INIT_VORGANG_ATTACHED_ITEM_DATA, {
    collection: MongoCollections.VORGANG_ATTACHED_ITEM,
    data,
  });
}

export function initVorgangData(data: VorgangE2E[]): void {
  dropCollection(MongoCollections.VORGANG);
  cy.task(CypressTasks.INIT_VORGANG_DATA, { collection: MongoCollections.VORGANG, data });
}

function dropCollection(collectionName: string): void {
  cy.task(CypressTasks.DROP_COLLECTIONS, [collectionName]);
}

export function initSearchIndexData(vorgaenge: VorgangE2E[]): void {
  vorgaenge.forEach((vorgang) => cy.addVorgangToSearchIndex(vorgang));
}

export function dropSearchIndex() {
  cy.removeAllDocumentsFromSearchIndex();
}

export function initUsermanagerData(data: UsermanagerUserE2E[]): void {
  //  cy.task(CypressTasks.DROP_USER_MANAGER_COLLECTIONS, [MongoCollections.USER]);
  cy.task(CypressTasks.INIT_USERMANAGER_DATA, { collection: MongoCollections.USER, data });
}

export function dropCollections(): void {
  cy.task(CypressTasks.DROP_COLLECTIONS, [
    MongoCollections.COMMAND,
    MongoCollections.VORGANG,
    MongoCollections.VORGANG_ATTACHED_ITEM,
    MongoCollections.OZG_CLOUD_FILE,
    MongoCollections.FS_FILES,
    MongoCollections.FS_CHUNKS,
  ]);
  //  cy.task(CypressTasks.DROP_USER_MANAGER_COLLECTIONS, [MongoCollections.USER]);
}

export function countDownloadFiles(): Cypress.Chainable<number> {
  return cy.task(CypressTasks.COUNT_FILES, DOWNLOAD_FOLDER);
}

export function deleteDownloadFolder() {
  return cy.task(CypressTasks.DELETE_FOLDER, DOWNLOAD_FOLDER);
}

export function unzipDownloadFile(file: string) {
  return cy.task(CypressTasks.UNZIP_FILE, { folderName: DOWNLOAD_FOLDER, fileName: file });
}

export function getDownloadFiles(): Cypress.Chainable<Array<string>> {
  return cy.task(CypressTasks.GET_DOWNLOAD_FILES, DOWNLOAD_FOLDER);
}

export function writeUserIdsIntoFile() {
  return cy.task(CypressTasks.WRITE_USER_IDS_TO_FILE, { collection: MongoCollections.USER });
}

export function scrollToWindowBottom(): void {
  cy.window().scrollTo('bottom');
}

export function scrollToWindowTop(): void {
  cy.window().scrollTo('top');
}

export function intercept(method: string, url: string): Cypress.Chainable<null> {
  return cy.intercept(method, url);
}

export function interceptWithResponse(method, url: RouteMatcher, response: RouteHandler): Cypress.Chainable<null> {
  return cy.intercept(method, url, response);
}

export function waitOfInterceptor(interceptor: string): Cypress.Chainable<Interception> {
  return cy.wait('@' + interceptor);
}

export function getTestElement(value: string) {
  return cy.getTestElement(value);
}

export function getElement(value: string) {
  return cy.get(value);
}

export function urlShouldInclude(text: string) {
  return cy.url().should('include', text);
}

//TODO: anders loesen -> bad practice
export function wait(ms: number, reason = ''): void {
  cy.wait(ms);
  if (reason) {
    console.log(`Had to wait ${ms}ms because of: ${reason}`);
  }
}

//

export function reload(): void {
  cy.reload();
}

export function readFileFromDownloads(fileName: string): Cypress.Chainable<any> {
  return cy.readFile(`${DOWNLOAD_FOLDER}/${fileName}`);
}

export function pressTab(): void {
  cy.realPress('Tab');
}

//Config
export function getBaseUrl(): string {
  return Cypress.config().baseUrl;
}

//Env
export function getCypressEnv(value: string) {
  return Cypress.env(value);
}

export function addSmockerMock(mock: SmockerMocks): void {
  cy.addMockToSmocker(mock);
}

export function resetSmocker(): void {
  cy.resetSmocker();
}

export function getDownloadFileAt(filePosition: number): Cypress.Chainable<string> {
  return getDownloadFiles().then((files) => readFileFromDownloads(files[filePosition]));
}