--- version: "current" language: "de" --- # Test-Studio ![Test-Studio.svg](https://help.cursor.de/__attachments/a_1d8cae9a2f81a8089f648ac4e23ecaed7a21abc91e825376b013c8c0a25708f8/Test-Studio.svg?cb=7d1f02fd25b28ed94ca1a35762c18130) 🧪 **Test-Studio** Die CRM-Lösungen von CURSOR zeichnen sich durch eine hohe Anpassungsfähigkeit aus. Im Rahmen des Customizing-Prozess ist dabei eine strenge Qualitätssicherung mit umfangreichen Tests unerlässlich. Das CURSOR-Test-Studio sorgt hier für deutliche Zeitersparnisse und einen konstant hohen Qualitätslevel: Das System führt komplexe, zeitgesteuerte Oberflächentests durch -- ganz ohne manuelles Eingreifen seitens der Anwender. [![Grundlagen.svg](https://help.cursor.de/__attachments/a_acf3d1329006b452b8c63ad0cde6e20a40591d17892f84e5e85578c2f72b466e/Grundlagen.svg?cb=eb9773955a1476f27fc39865e5e9413f)](/de/tstudio/current/grundlegendes-konzept.md) **Konzept** [![Funktionen.svg](https://help.cursor.de/__attachments/a_082bcb4ef15dbf72b7a7cd3653dc6d182aefe43a2a32d429f0a5bfc8c6f96187/Funktionen.svg?cb=bb344060a4d2d0546bee05cddeff5e81)](/de/tstudio/current/funktionsubersicht.md) **Funktionsübersicht** [![Anwenderhandbuch.svg](https://help.cursor.de/__attachments/a_4fc57551dc3abb205e9c1f80cf48c123d38d99a4bf2afa04f86bb04893af5b05/Anwenderhandbuch.svg?cb=fc475ccca21afc4cf2220827d957fe79)](/de/tstudio/current/anwenderdokumentation.md) **Anwenderdokumentation** [![Administratorhandbuch.svg](https://help.cursor.de/__attachments/a_d49c755c274ba863bb923bae20ebed5cd9f256976cd9c1366546ff9bf1a8d763/Administratorhandbuch.svg?cb=dff113df1e410d23f7d43418678cfbe9)](/de/tstudio/current/administrationsdokumentation.md) **Administration** [![FAQs.svg](https://help.cursor.de/__attachments/a_f6c7d5e624196543a530356a49840442e1a1e8119e8a5ae47ff765a537328b40/FAQs.svg?cb=13b1a136333be22471a067791cd291cc)](/de/tstudio/current/haufig-gestellte-fragen-faqs.md) **FAQs** --- version: "current" language: "de" --- # Administrationsdokumentation **Administrationshandbuch** * [Quick Start Guide](https://help.cursor.de/de/tstudio/current/quick-start-guide.md) * [Installation und Update](https://help.cursor.de/de/tstudio/current/installation-und-update.md) * [Technischer Kommunikationsplan der CURSOR-Test-Studio Komponenten](https://help.cursor.de/de/tstudio/current/technischer-kommunikationsplan-der-cursor-test-stu.md) * [Administrative Vorgabe von Einstellungen](https://help.cursor.de/de/tstudio/current/administrative-vorgabe-von-einstellungen.md) * [Release-Notes für das CURSOR-Test-Studio](https://help.cursor.de/de/tstudio/current/release-notes-fur-das-cursor-test-studio.md) ![Administratorhandbuch.svg](https://help.cursor.de/__attachments/a_9037658d3047feba7f8dbac8cfb074d8b2a9ac880ade24368823dfd2d24bc980/Administratorhandbuch.svg?cb=dff113df1e410d23f7d43418678cfbe9) --- version: "current" language: "de" --- # Administrative Vorgabe von Einstellungen Alle Einstellungen, die auch durch den Anwender getätigt werden können, können zentral vorgegeben werden. Solche vorgegebenen Einstellungen können durch den Anwender nicht mehr überschrieben werden. ## Vorbereitung Die zentral vorgegeben Einstellungen werden in einer `*.properties `Datei verwaltet, die in der `configuration.bat` hinterlegt wird: SET ADMIN_CONFIG_OVERRIDE=\\SERVER\adminSettings.properties Alternativ kann die Vorgabe auch nur für bestimmte Anwender oder Rechner erzwungen werden: IF /i "%COMPUTERNAME%" == "MY-MACHINE" ( SET ADMIN_CONFIG_OVERRIDE=\\SERVER\adminSettings.properties ) REM oder IF /i "%USERNAME%" == "$gMSA_User$" ( SET ADMIN_CONFIG_OVERRIDE=\\SERVER\adminSettings.properties ) Diese Datei sollte von nicht-administrativen Anwendern selbstverständlich nur gelesen werden dürfen. ## Vorgabe von Einstellungen, die nicht geändert werden dürfen Die Einstellungen werden in der oben konfigurierten `*.properties`-Datei hinterlegt. Die Einträge sind von der Form interne.id.der.einstellung=meinWert wobei in Pfadangaben ein \\ als \\\\ zu schreiben ist. Die wichtigsten Einstellungen sind unter aufgeführt. Darüber hinaus können Sie hiermit für alle Test-Maintainer Stellvertreter für den Nutzerwechsel hinterlegen. Bitte beachten Sie, dass es sich hierbei um einen Sonderfall handelt, da eine flexible Anzahl von Stellvertretern eingerichtet werden kann. Jeder Eintrag in Ihrer Konfiguration sollte mit dem Prefix `teststudio.switch.user.` beginnen, gefolgt von der Bezeichnung des Alias. Ein Beispiel für einen solchen Eintrag wäre `teststudio.switch.user.administrator`, gefolgt vom entsprechenden Wert des Alias. Um den Alias `administrator` mit dem Wert „Admin Admin" zu hinterlegen, fügen Sie in Ihrer Datei den folgenden Eintrag hinzu: `teststudio.switch.user.administrator=Admin Admin`. Weitere Details zur Verwendung des Nutzerwechsels können im Abschnitt eingesehen werden. ## Vorgabe von Einstellungen, die geändert werden dürfen Einstellungen, die in der `configuration.bat` vorgenommen werden, können benutzerindividuell übersteuert werden. Die Vorgabewerte werden in der `configuration.bat` nach dem Schema SET INTERNE_ID_DER_EINSTELLUNG=meinWert hinterlegt. Über IF-Statements (s.o.) können diese Vorgaben auf bestimmte Anwender oder Rechner eingeschränkt werden. ## Wichtige Einstellungen | **Name der Einstellung** | **Beschreibung** | |-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | teststudio.engine.driver.chrome | Der Pfad zur Chrome Binärdatei | | teststudio.engine.driver.firefox | Der Pfad zur Firefox Binärdatei | | teststudio.engine.driver.edge | Der Pfad zur Edge Binärdatei | | teststudio.customizing.username | Der Nutzername | | teststudio.customizing.password | Das Passwort des Nutzers (maskiert) | | teststudio.customizing.url | Die URL des Testsystems | | teststudio. ![question mark](https://help.cursor.de/__attachments/a_34920cb077b11d883dc2a86a79aefa8ea0848590a963a8e2fad3a00d60b22edf/atlassian-question_mark?cb=01451d3e8ed02077899ec3e8fa8cf364) | Name der Konfigurationsdatei (configuration.bat) ![question mark](https://help.cursor.de/__attachments/a_34920cb077b11d883dc2a86a79aefa8ea0848590a963a8e2fad3a00d60b22edf/atlassian-question_mark?cb=01451d3e8ed02077899ec3e8fa8cf364) | **Nutzerpasswort** Das Nutzerpasswort müssen Sie verschleiert (maskiert) hinterlegen. Dies können Sie wie im Schaubild gezeigt durchführen. ![Test-Studio-Passwort-verschleiern.png](https://help.cursor.de/__attachments/a_2ae081bf16901182a8a75afd9c080ffb32a4bdc078d34a9b5a835aca32591c4c/Test-Studio-Passwort-verschleiern.png?cb=540d0758de926bbfb918cfefa17b7bc8) --- version: "current" language: "de" --- # Anwenderdokumentation **Weitere Kapitel** * [Konfiguration und Einstellungen](https://help.cursor.de/de/tstudio/current/konfiguration-und-einstellungen.md) * [Umstellung Lesemodus](https://help.cursor.de/de/tstudio/current/umstellung-lesemodus.md) * [Testergebnisse im CRM](https://help.cursor.de/de/tstudio/current/testergebnisse-im-crm.md) * [Beispiel-Testfälle](https://help.cursor.de/de/tstudio/current/beispiel-testfalle.md) * [Bekannte Einschränkungen](https://help.cursor.de/de/tstudio/current/bekannte-einschrankungen.md) ![Anwenderhandbuch.svg](https://help.cursor.de/__attachments/a_c44d12c1dab2c79bfd2eea734bdb813eba34af50e31ff2d2fe775a0b6f466cbd/Anwenderhandbuch.svg?cb=fc475ccca21afc4cf2220827d957fe79) ## Start der Anwendung Das CURSOR Test-Studio kann über die voreingestellte Desktopverknüpfung aufgerufen werden. Alternativ öffnet sich die Anwendung durch Doppelklick auf eine Test-Studio Datei. Der ausgewählte Testfall wird bei der zweiten Variante sofort geöffnet und kann bearbeitet werden. Wurden keine Login-Daten für den Benutzer hinterlegt, mit dem die Tests ausgeführt werden sollen, werden diese abgefragt: ![image-20240125-094048.png](https://help.cursor.de/__attachments/a_50a82b7f7c07b17ca0d339a60bde185a36e38811bd094d8380d22d242c8c7708/image-20240125-094048.png?cb=f5b256d1186bddd721710a2bb4899d1d) ## Übersicht über die Anwendung Das CURSOR Test-Studio besteht aus vier Bereichen: der Workspaceübersicht, der Menüleiste, dem Eingabe- und dem Protokoll-Bereich. ### Menüleiste Über die Menüleiste kann auf alle wichtigen Funktionen der Anwendung zugegriffen werden. | ![Save.svg](https://help.cursor.de/__attachments/a_8cb2be7541c3cde3631fc9a684e699a27017fb64dade7a4364edaaf317bf294e/Save.svg?cb=2a912d5cd5c31301d3e72c8f1238554a) **Speichern** | Speichert das geöffnete Dokument unter dem bereits vorhandenen Namen ab. Das Feld ist bei Neuanlage ausgegraut. | | ![StartScript.svg](https://help.cursor.de/__attachments/a_fd1ef02902c8a7a6a44c2dbff27aa0b8de9aa19a8bc891ad2e6b6bc874a04051/StartScript.svg?cb=2cdef689ed39cd5c4d673f9ff65f74ef) **Ausführen** | Startet den Testfall. Das verknüpfte Testsystem wird in einem neuen Browser-Fenster geöffnet und der Testfall durchgeführt. Währenddessen werden Log und Protokoll gefüllt. Nach Abschluss des Tests erhält der Anwender einen Dialog mit der Info, ob während des Durchlaufs ein Fehler auftrat oder nicht. Ist der Button deaktiviert, wurden entweder kein Benutzername und Passwort gespeichert oder der Login-Dialog abgebrochen. Dann müssen vor der Testausführung Login-Daten via *Entsperren* hinterlegt werden. | | ![Configuration.svg](https://help.cursor.de/__attachments/a_6e06a832e9f66e173df985dedd239a2f2a7c433fdced635831e4d1452c34d094/Configuration.svg?cb=9f4d935b3b4ee26113edb999f8f64cd6) **Einstellungen** | Die (De-)Aktivierung des Demo-Modus, Einstellungen zum Log-Level und dem Headless-Mode können hier vorgenommen werden. Weitere Informationen siehe [**Konfiguration und Einstellungen**](https://help.cursor.de/de/tstudio/current/konfiguration-und-einstellungen.md). | | ![SecurityConfiguration.svg](https://help.cursor.de/__attachments/a_83e30674a256e891eb3cada0e6e04d9a347d9a3aae3c6c09bcb0f0fe18005e0d/SecurityConfiguration.svg?cb=af768b9d76995e7e14e200aad735410c) **Entsperren** | Ermöglicht das nachträgliche Hinterlegen von Login-Daten, vgl. *Ausführen*. | | ![MethodPublic.svg](https://help.cursor.de/__attachments/a_ad015f5c82a2a70139c00cd9f2e6b2e2a9c64b0e5a28095b51ca1574aafae0c4/MethodPublic.svg?cb=0c5957da3d21b07fc8a139f5d2b27b0e) **Autovervollständigung** | Befindet sich hier ein grüner Kreis, ist die Autovervollständigung aktiv. Bei einem roten Kreis ist sie inaktiv, bei einem gelben eingeschränkt verfügbar. (Mehr dazu siehe Abschnitt Autovervollständigung) | |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | ![ProcessCancel.svg](https://help.cursor.de/__attachments/a_22fbd6ffbea05634efedf78c90dfc10cc448e1fa75fe902ea4bfbb118921f9df/ProcessCancel.svg?cb=bbcc0840edc5dea38e698077f3986c86) **Interaktiven Modus verlassen** | Wurde im Feld "Breakpoint" ein solcher angegeben, stoppt die Testausführung vor der entsprechenden Zeile. Möchte man diesen Interaktiven Modus verlassen, muss dieser Button betätigt werden. Weitere Informationen zum Interaktiven Modus können [**hier**](https://help.cursor.de/de/tstudio/current/interaktiver-modus.md) eingesehen werden. | | ![AddStartScriptAction.svg](https://help.cursor.de/__attachments/a_d57b5ef9e667afc3f667d0d88a02dac2a39b451eb870ae1c11b4fe764d263fc1/AddStartScriptAction.svg?cb=6bdc94de7f1a60ad28149ed30ddd8c6e) **Auswahl ausführen** | Wurde im Feld "Breakpoint" ein solcher angegeben, stoppt die Testausführung vor der entsprechenden Zeile. Möchte man anschließend mit der Testausführung fortfahren, so markiert man die entsprechenden Zeilen im Test und betätigt anschließend diesen Button. | | ![ClassificationStandard.svg](https://help.cursor.de/__attachments/a_8812f1ce2fa38f6eff1e159cb1e97e006055c5ba9abf8c3b817fe11cfa94d0c3/ClassificationStandard.svg?cb=2e158e75ffb8b386125b03f3b58abe91) **Breakpoint:** | Das Feld "Breakpoint" dient zur Angabe, bis wohin der Testfall im interaktiven Modus ausgeführt werden soll. Die angegebene Zeile wird dabei **nicht** mit ausgeführt. | | ![Delete.svg](https://help.cursor.de/__attachments/a_45cf600a9df06b6da1a5a9adc4cf395243fe19656adc9fd4b0e85e8188c1db52/Delete.svg?cb=28ecb8af9db8f8ae607608ea534e855b) **Breakpoint löschen** | Um die Breakpoint-Angabe zu leeren, kann das Mülleimer-Icon verwendet werden. | |---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| ### Workspace-Übersicht Es kann immer genau ein Workspace im Test-Studio geöffnet werden. Hier werden alle Bibliotheken und Testfälle des ausgewählten Workspaces aufgelistet. Üblicherweise werden thematisch zusammengehörende Testfälle in einem gemeinsamen Verzeichnis abgelegt. Durch Doppelklick auf eine Bibliothek oder einen Test wird die ensprechende Datei im Eingabebereich des Studios geöffnet. Weitere Funktionen innerhalb der Baumstruktur: | ![icons8-document.svg](https://help.cursor.de/__attachments/a_8d5ae84ed9d20bde62b369408c04c3e02a1ed01683fa589a784c82962128843f/icons8-document.svg?cb=c42fa8ee1a91277dd63c1a6e37d78bc1) **Neu** | Erstellt einen weiteren Testfall in einer neuen Datei. Über einen Rechts-Klick in der Testübersicht möglich. ![image2022-10-27_13-35-53.png](https://help.cursor.de/__attachments/a_a5cd382f139375d10e85df5764f3896250ab164340588b06d78379893dbc42f9/image2022-10-27_13-35-53.png?cb=ffaf592336696605c59ffc466414d0bd) | | ![Delete.svg](https://help.cursor.de/__attachments/a_45cf600a9df06b6da1a5a9adc4cf395243fe19656adc9fd4b0e85e8188c1db52/Delete.svg?cb=28ecb8af9db8f8ae607608ea534e855b) **Löschen** | Der ausgewählte Testfall kann über den Rechts-Klick in der Testübersicht gelöscht werden. | | ![FolderNew.svg](https://help.cursor.de/__attachments/a_3dd6d42446424dedb27b143585afea05492dc4af7272aa2f8f73925023287ad0/FolderNew.svg?cb=9cead4d2910a4cb8df37d4b42fddd303) **Neuer Ordner** | In der Testübersicht kann ebenfalls mit einem Rechts-Klick eine neue Ordner-Struktur angelegt werden. | |---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| Ist ein Workspace durch einen User geöffnet, wird er für alle anderen User automatisch gesperrt. Somit wird sichergestellt, dass sich zwei Anwender ihre Tests nicht gegenseitig überschreiben. Details siehe [Sperrkonzept Workspace](https://help.cursor.de/de/tstudio/current/sperrkonzept-workspace.md). ### Eingabebereich Im Eingabebereich wird der Testfall definiert. Wird ein Workspace erneut geöffnet, wird hier automatisch der vom angemeldeten User zuletzt verwendete Testfall geöffnet. Weitere Informationen siehe unter [**Aufbau eines Testfalls**](https://help.cursor.de/de/tstudio/current/anwenderdokumentation.md#Aufbau-eines-Testfalls-%255BinlineExtension%255D) und [**Keywords**](https://help.cursor.de/de/tstudio/current/keywords.md). ![image2020-3-11_16-47-21.png](https://help.cursor.de/__attachments/a_a004abe964cef62ea937663aec8417798b772b713b032f18a7726c31d57ddf16/image2020-3-11_16-47-21.png?cb=8dd4f3ec8e05e157fa430ad3e78f6a5d) #### Tastenkürzel Alle wichtigen Aktionen des Test-Studios sind über die Tastatur bedienbar: * Online-Hilfe F1 * Neue Datei: STRG + N * Laden: STRG + O * Speichern: STRG + S * Speichern als: STRG + UMSCHALT ⇧ + S * Protokoll: STRG + T * Protokoll speichern: STRG + S * Protokoll laden: STRG + O * Protokoll an CRM senden: STRG + UMSCHALT ⇧ + S * Protokoll leeren: STRG + D * Screenshot anzeigen: STRG + UMSCHALT ⇧ + I * StackTrace anzeigen: STRG + UMSCHALT ⇧ + E * Ausführen: STRG + R * Einstellungen: STRG + E * Innerhalb des Editors * Aktuellen Testschritt ein-/ausklappen: STRG +. * Alle Testschritte einklappen: STRG + ALT +. * Suchen: STRG + F * Suchen und Ersetzen: STRG + H #### Autovervollständigung Ist die Autovervollständigung aktiviert, so kann der Anwender mit der Tastenkombination STRG + LEERTASTE auf diese zugreifen. Keywords und alle im System verfügbaren Feldnamen und Entitäten können ergänzt werden, indem der Anwender die ersten Buchstaben eingibt und die Tastenkombination ausführt. So öffnet sich ein Index mit möglichen Wortendungen, indem der Anwender durch Mausklick oder mittels Pfeiltasten navigieren kann. Mit Mausklick oder der Enter-Taste kann das gewünschte Element ausgewählt werden. Gibt es keine Auswahlmöglichkeiten, so ergänzt das Programm das Wort / die Wörter automatisch. Die Autovervollständigung ermöglicht außerdem, dass der Anwender nach einer Entität mittels ihrer Bezeichnung suchen kann, der technischen Feldnamen ist nicht erforderlich. Das Verhalten der Autovervollständigung ist an die Skript-Editoren aus dem Rich-Client und BPM angelehnt. **Beispiel:** Gibt der Anwender "Ges" ein und betätigt STRG + LEERTASTE , ergänzt das Programm den Eintrag automatisch, indem es den technischen Feldnamen "Customer" einfügt. Gibt der Anwender "Ge" ein und betätigt STRG + LEERTASTE , so erhält er eine Auswahl an möglichen Wortendungen. ![image2020-3-11_16-46-21.png](https://help.cursor.de/__attachments/a_eea0aeef699f725c55d7f8d6f6b47c6934cb0515123a7ec7e3ecc1cc5c6699ac/image2020-3-11_16-46-21.png?cb=0402f65c757649ed964c4275aa1bf03c) #### Keywords Unter Verwendung von Keywords bestimmt der Anwender die Schritte, die das Test-Studio in der Anwendung ausführt. (Mehr dazu siehe [Keywords](https://help.cursor.de/de/tstudio/current/keywords.md)*)* ### Protokoll-Bereich Das Protokoll spiegelt den Testablauf wider. In einer Baumstruktur werden die einzelnen Testläufe angezeigt und bis auf Testschrittebene aufgegliedert. Weitere Informationen zu der Protokollansicht sind [**hier**](https://help.cursor.de/de/tstudio/current/protokollansicht.md) nachzulesen. ![image2022-10-26_14-29-38.png](https://help.cursor.de/__attachments/a_26e8d243a5c31ba0d49b674c39eca022680c6c8a5fafef1b0d19403d495babb5/image2022-10-26_14-29-38.png?cb=2a49a597e70cebceda45ddedf9980898) Die Lasche "Fehler" beinhaltet nur Einträge wenn in der aktuell im Eingabebereich geöffneten Datei Synthaxfehler vorliegen. Hier befinden sich Hilfestellungen um diese Fehler zu identifizieren und zu beheben. ### Aufbau eines Testfalls Der Name der Testklasse wird zu Beginn definiert. Sie steht über den einzelnen Testfällen und fasst diese zu einer Einheit, der Testklasse zusammen. Anschließend folgt die Benennung des einzelnen Testfalls. Darunter folgen die Testschritte, diese werden durch das Keyword „given:" eingeleitet. Als „Testschritt" versteht man die einzelne Aktion, die der Test für den User auf der Maske ausführt, wie beispielsweise die Geschäftspartnerebene zu öffnen. Testschritte werden in der Reihenfolge ausgeführt, in der sie definiert werden. Ein automatisierter Test im CURSOR-Test-Studio kann nur eine Klasse haben. Innerhalb dieser können sich beliebig viele Testfälle mit jeweils beliebig vielen Testschritten befinden. #### **Testbeispiel** class MeinTest extends BaseWebClientSpec { // MeinTest = Name des Testschrittes, welcher im Log angezeigt wird def "Öffne GP Mustermann"() { // Leitet Testschritt "Öffne GP Mustermann" ein given: // Kennzeichnung, dass es sich hierbei um einen Testfall handelt open entity "Customer" // meine Aktion: Geschäftspartnerebene öffnen execute search // Suche ausführen open 1st dataset // öffnet den ersten Datensatz der Suche current view should belong to "Customer" // Prüfung: ist Geschäftspartnerebene geöffnet? field "Name1.Customer" should be "Mustermann" // Prüfung: ist der Wert im Feld "Name1.Customer" = Mustermann? } def "Mache etwas mit dem GP Mustermann ..."(){ given: // Der zweite Testschritt, siehe oben... } } **Tipp** Im Test können Kommentare hinterlegt werden. Dadurch können auch Keywords temporär deaktiviert werden. // Dies ist ein einzeiliger Kommentar. /* Und dies ein Mehrzeiliger. */ --- version: "current" language: "de" --- # Beispiel-Testfälle Hier wurden einige vollständige Beispiele aufgeführt, um den Start mit dem Test-Studio zu erleichtern. **Tipp** Um die Art, wie das Test-Studio Tests ausführt, besser kennenzulernen, empfiehlt es sich, den **Demo-Modus** zu aktivieren. ## Neuanlage einer Aktivität ### **Neuanlage einer Aktivität** Groovy class NeueAktivitaet extends BaseWebClientSpec { def "Neuanlage anstoßen"() { given: open entity "Activity" current view should be listview // Auf den Aktivitäten ist eine Einfeldsuche konfiguriert create dataset current view should be detailmask } def "Vorbedingungen auf der Maske prüfen"(){ given: field "ActTypeKey.Activity" should be mandatory field "Subject.Activity" should be blank // weitere Prüfungen ... } def "Befüllen der notwendigen Felder"(){ given: set field "Subject.Activity" to "Eine Aktivität aus dem Test-Studio!" set field "ActTypeKey.Activity" to "ERINNERUNG" } def "Speichern der Aktivität"() { given: save dataset } def "Schließen der Ebene"(){ given: close level // gute Tests beginnen und enden stets auf dem Cockpit } } ## Einen Geschäftspartner öffnen und eine neue zugeordnete Aktivität erstellen **Vorbereitungen** Einen Geschäftspartner im myCRM ablegen. Der Eintrag hat den Namen "Mein Kunde". ### **Öffnen eines Geschäftspartner aus dem myCRM und Neuanlage einer ungerordneten Aktivität** Groovy class AktivitaetZuBestehendemGeschaetspartner extends BaseWebClientSpec { def "Geschäftspartner über myCRM öffnen"() { given: click myCrm >> "Mein Kunde" current view should be detailmask current view should belong to "Customer" } def "Neuanlage Aktivität initiieren"(){ given: open subdata entity "Activity" create dependent dataset } def "Neuanlage Aktivität durchführen"(){ given: current view should be detailmask current view should belong to "Activity" set field "Subject.Activity" to "Neue Aktivität unterhalb meines Kunden" set field "ActTypeKey.Activity" to "ERINNERUNG" save dataset } def "Zurück zum Geschäftspartner"() { given: go back current view should be detailmask current view should belong to "Customer" } def "Erneutes Öffnen der neu angelegten Aktivität"(){ given: open dataset matching { field "Subject.Activity" equals "Neue Aktivität unterhalb meines Kunden" } current view should be detailmask current view should belong to "Activity" } def "Schließen der Ebene"(){ given: close level // gute Tests beginnen und enden stets auf dem Cockpit } } --- version: "current" language: "de" --- # Bekannte Einschränkungen Grundsätzlich Das Test-Studio ist ein maßgeschneidertes Oberflächentesting-Tool, welches eine Vielzahl von Funktionalitäten im CRM mit einfachen Keywords überprüfen kann. Es kann noch nicht alles, was in der Anwendung sichtbar ist, auch über das Test-Studio abgebildet werden, sondern nur das, wofür es auch ein Keyword gibt. Außerdem ist es wichtig, dass die Bereiche, die durch Keywords bedient werden für den Test-Studio Benutzer eingeblendet sind. Daher ist darauf zu achten, dass Funktionalitäten, die die Oberfläche autom. anpassen (Zen-Modus, Onboarding-Assistent), für den ausführenden User deaktiviert sind. Feldprüfung in einem Datumsfeld **Problem** Das Keyword `field "SomeDateWithTimeField.Entity" should be blank` prüft nur den Inhalt des Datumfeldes, nicht aber des Zeitfeldes. **Lösung** Das stellt meist keine Einschränkung dar, denn 1. ist Feld ist beim Betreten der Maske leer, so sind dies sowohl das Datums- als auch das Zeitfeld. 2. das Keyword `clear field "SomeDateWithTimeField.Entity"` leert beide Felder Auswahl eines bestimmten Datensatzes in Listen mit mehreren Seiten **Problem** In Listen kann mit "select rows matching" nur die erste Seite durchsucht werden. Bei einem Suchergebnis, welches sich über mehrere Seiten erstreckt, kann das Studio nicht mittels Paginator auf die weiteren Seiten navigieren. **Lösung** Das stellt meist keine Einschränkung dar, da die meisten Listen sich nicht über mehrere Seiten erstrecken. Nachschlagefelder bei denen eine Suche bereits automatisch Ausgeführt wird **Problem** Möchte ich ein Nachschlagefeld über das Keyword *set lookupfield "fieldname" through searching using searchParameter*füllen, so darf in diesem Feld keine Suche automatisch ausgeführt werden. Das Test-Studio erwartet nach dem Betätigen des Nachschlage-Icons eine Suchmaske, auf welcher die im Keyword definierten Parameter einetragen werden können. **Lösung** Diese besonderen Nachschlagefelder können aktuell nur mittels *set field "fieldname" to* gefüllt werden und sind somit vom Lucene-Index abhängig. Bedienung von Infoboards **Problem** Die Bedienung von Infobards (Desktop und Entitätsboards) ist aktuell nicht möglich. **Lösung** Mit der neuen Infoboardtechnologie (Stichwort Kachel 2.0) wird es langfristig Möglichkeiten geben, auch Infoboards mit dem Test-Studio zu bedienen. Zum aktuellen Stand ist dies aber noch nicht möglich. Dokumentenhandling **Problem** Das allgemeine Dokumentenhandling (Ausleihen, Zurückgeben, etc.) erfordert eine Browsererweiterung und ist daher aktuell nicht im Umfang der Test-Studio-Funktionalitäten enthalten. Befüllen von Datumsfelder mit der Maskenkomponente "DateTextField" und über Feldeigenschaften eingeblendetem Zeitfeld **Problem** Hat ein Datumsfeld die Maskenkomponente "DateTextField" und wurde dazu das Zeitfeld über die Feldeigenschaft 'Zeitfeld anzeigen' eingeblendet, so kann es über das Standard-Keyword *set field "TestDate.TestEntity" to "value"* nicht befüllt werden. **Lösung** Statt des allgemeinen Keywords kann folgender Code vorrübergehend als Workaround zum Befüllen verwendet werden: set datefield "TestDate.TestEntity" to "10.01.2023 13:33" Firefox: Scrollen in der automatischen Ausführung nicht möglich **Problem** In Firefox kann das Füllen von Feldern zu einem Fehler führen, falls sich das Feld nicht im sichtbaren Bereich des Browsers befindet. Das ist zum Beispiel der Fall, wenn man als Nutzer auf einer Maske zu einem Feld scrollen muss. Das liegt an einer grundsätzlichen technischen Abweichung von Firefox im Gegensatz zu anderen Browsern. **Lösung** Durch das Setzen folgender Einstellungen wird der Bildschirm im „Headless-Modus" entsprechend so skaliert, sodass kein Scrollen mehr notwendig sein sollte. In der customSettings.properties: teststudio.engine.headless.window.size.x=4000 teststudio.engine.headless.window.size.y=4000 oder per configuration.bat: set TESTSTUDIO_ENGINE_HEADLESS_WINDOW_SIZE_X=4000 set TESTSTUDIO_ENGINE_HEADLESS_WINDOW_SIZE_Y=4000 --- version: "current" language: "de" --- # Controlling der Testergebnisse im CRM Die Testergebnisse eines Testlaufs können in ein definiertes Report-CRM importiert werden. Details zur Einrichtung des Report-CRMs können hier eingesehen werden: [Konfiguration und Einstellungen](https://help.cursor.de/de/tstudio/current/konfiguration-und-einstellungen.md) . Häufig wird das System, auf dem getestet wird, auch gleichzeitig als Report-CRM verwendet. ## Testläufe Das Ergebnis eines Testlaufs wird in der Entität „Testläufe" (ScriptTestRun) mit dem Typ „Test-Studio" gespeichert. ![grafik-20240718-121856.png](https://help.cursor.de/__attachments/a_dab510b5e6c470e0dd20260d933d6f00527cec242ec270ca41fb088be57561df/grafik-20240718-121856.png?cb=76c36867e746bac2776526f4dc998e9d) ## Testfälle Die einzelnen, während des Testlaufs ausgeführten, Testfälle sind in der Entität "Testfälle" im Unterbereich des Testlaufs verknüpft. Da Testfälle häufig im Workspace je nach fachlichem Zusammenhang in verschiedenen Verzeichnissen untergebracht werden, kann man den Dateipfad zu einem Testfall auch im CRM einsehen. Er wird im Feld „Testsammlung" ausgegeben und ermöglicht somit die Gruppierung von Testergebnissen nach fachlichen Rubriken. ![grafik-20240724-111700.png](https://help.cursor.de/__attachments/a_87462e627c72f4c1e0fc44416a85031f6606e87d17982fa4815f25506dbffbd8/grafik-20240724-111700.png?cb=05173aa2d32f71252e5d0d0575bc18de) Screenshot eines Testfalls aus einem automatisiert gestartetem Testlaufs mit Testsammlung. Das Feld „Testsammlung" ist nicht gefüllt, wenn ein Testlauf manuell gestartet wurde. Das Test-Studio muss mittels 'CURSOR_TestStudio_batch.bat' aufgerufen werden, da die Information nur während der Ausführung mittels CLI zur Verfügung steht. Das Flag „Erfolgreich" kennzeichnet, ob im Testlauf ein Fehler bei diesem Testfall aufgetreten ist. Ist das Flag nicht gesetzt, bedeutet dies, dass mindestens einer der zugeordneten Testfälle fehlgeschlagen ist. ![grafik-20240718-122149.png](https://help.cursor.de/__attachments/a_f74118cb65d3902c301e7d7120b8e7459a69b98a1426e3bd7e47509ddbac49b6/grafik-20240718-122149.png?cb=a26eaaba1982fef683713745d820a82e) Bei einem manuell gestartetem Testlauf ist das Feld "Testsammlung" des Testfalls leer und ausgeblendet. ## Testschritte Unterhalb eines Testfalls sind die Testschritte verknüpft. Der Name, der im Test-Studio-Code für den Testschritt vergeben wurde, ist hier als "Name / Methodenname" aufgeführt. Es empfiehlt sich diesen so zu wählen, dass er auf den Inhalt des Testschritts schließen lässt. Auch hier kennzeichnet das Flag „Erfolgreich", ob ein Testschritt fehlerhaft ausgeführt werden konnte. Ist es nicht gesetzt, bedeutet dies, dass mindestens ein Testschritt nicht vollständig ausgeführt werden konnte. Sobald ein Testschritt fehlgeschlagen ist, werden keine weiteren Testschritte ausgeführt, sie werden dann automatisch als fehlerhaft im Testergebnis vermerkt. ![grafik-20240718-122509.png](https://help.cursor.de/__attachments/a_1d082cc99401a63e5a8f01e0efa7608d7e0cf35aaef3008176f118d0ae1f35c2/grafik-20240718-122509.png?cb=f24a2ffd678b2133989ab5a8a5c46219) --- version: "current" language: "de" --- # Editorfunktionen des Test-Studios ## Automatische Vervollständigung Das Test-Studio besitzt verschiedenen Funktionen, um den Testersteller beim Schreiben eines Testfalls zu unterstützen. Zur Unterstützung bei der Testerstellung bietet der Editor des Test-Studios eine Autovervollständigung. Durch die Tastenkombination STRG + LEERTASTE wird eine Vorschlagsliste mit allen zu dieser Stelle passenden Elementen geöffnet. Für das ausgewählte Element in der Vorschlagsliste wird rechts daneben die zugehörige Dokumentation angezeigt. Mit der Entertaste wird das ausgewählte Element vervollständigt. Durch die Platzhalter für bspw. Parameter eines Keywords kann mit der Taste ↹ TAB gesprungen werden. ![image2022-8-2_15-51-2.png](https://help.cursor.de/__attachments/a_8f79dd13da9e7e2d8f252325f42925af570d200baedb3763aa865fe900a0154a/image2022-8-2_15-51-2.png?cb=1542ae00b67582088d116a36633c6eb4) Das Test-Studio bietet die Vervollständigung für die folgenden Elemente an: * Keywords * technische Entitäts-, Feld- und Relationsnamen, sofern ein gültiges System für die Metadatenbeschaffung konfiguriert worden ist * Testschrittbibliotheken und deren Methoden * Variablen * Im [interaktiven Modus](https://help.cursor.de/de/tstudio/current/interaktiver-modus.md) stehen zusätzliche Vervollständigungen für Buttons, Labels, Tabs, Collapsibles, Aktionsboxschalter, myCRM Einträge und BPM-Instanzen zur Verfügung. Bei Feld- und Relationsnamen und Methoden von Testschrittbibliotheken erfolgt die Vervollständigung zweistufig. Das bedeutet, dass bei Feldnamen zuerst die Entität, bei Relationsnamen die Hauptentität und bei Bibliotheksmethoden die Bibliothek vorgeschlagen wird. Nach der Übernahme eines Vorschlags ist ein Punkt einzugeben und erneut die Vorschlagsliste mit STRG + LEERTASTE zu öffnen. Nun wird der eigentliche Feldname, Relationsname oder Methodenname in diesem zweiten Schritt vorgeschlagen. Nach Auswahl des passenden Vorschlags wird im Falle eines Feld- oder Relationsnamens der entsprechende technische Name eingefügt. ![image2022-8-2_15-51-57.png](https://help.cursor.de/__attachments/a_36854cec94517e78cf5c37904d8c10e641b5f379eec400106875a847aab07517/image2022-8-2_15-51-57.png?cb=52c8e35fd3d988cfb10b45146991eddf) ## Dokumentation Zur Dokumentation von Testfällen, Testschritten, Variablen, Testschrittbibliotheken und Bibliotheksmethoden werden spezielle Kommentare (javadoc) verwendet. ![image2022-8-2_16-19-50.png](https://help.cursor.de/__attachments/a_64c04674921ed99e18a10e19890db67fdb63d788297467d15e388be8f49a343f/image2022-8-2_16-19-50.png?cb=1440b689ab6e1d887f3f2f0f70fc723b) Für die Dokumentation von Methoden in Testschrittbibliotheken bietet das Test-Studio als Unterstützung eine Vorlage für einen solchen Kommentar. Durch das Tippen von `/**` gefolgt von der Entertaste wird eine Vorlage für einen solchen Dokumentationskommentar erzeugt. Dieser enthält einen Platzhalter für eine allgemeine Beschreibung und zusätzlich Platzhalter für die Beschreibung von jedem Parameter. ![image2022-8-1_12-32-11.png](https://help.cursor.de/__attachments/a_e09c93fc7aac7157563152d39c9a24241d456d794a8a3e0b7026317ff4502bc3/image2022-8-1_12-32-11.png?cb=356aba9c2fea9388d6f6e2b08131982d) ## Tooltips Um das Verstehen eines bereits bestehenden Testfalls zu erleichtern, bietet das Test-Studio für die folgenden Elemente Tooltips mit entsprechenden Zusatzinformationen an: * technische Entitäts-, Feld- und Relationsnamen, sofern ein gültiges System für die Metadatenbeschaffung konfiguriert worden ist * Verwendungen von Variablen und Methoden von Testschrittbibliotheken, sofern diese mit einem speziellen Kommentar dokumentiert worden sind ![image2022-8-2_16-13-51.png](https://help.cursor.de/__attachments/a_1ea14b7b76dd94217e1fcb0230d658aa3b15425261f525d180adbba9eba20ba1/image2022-8-2_16-13-51.png?cb=e0377d185d50b769ba300e3ce85aff5e) ![image2022-11-3_10-24-54.png](https://help.cursor.de/__attachments/a_7283be5fecad7c5338e0f0ee2ce2d2ed471a0a3722868b0eefb4346be93976ba/image2022-11-3_10-24-54.png?cb=5145895d455fb1d06cb5036f8749b514) ## Hervorhebung von Fehlern Das Test-Studio zeigt bereits während des Schreibens eines Testfalls an, ob Syntaxfehler enthalten sind. Enthaltene Fehler werden direkt im Editor markiert. ![image2022-11-3_10-23-45.png](https://help.cursor.de/__attachments/a_e5f9d613ae3961fe4a41262f4f0cfb55dad26241033e3f59fa4ac74a94c950ab/image2022-11-3_10-23-45.png?cb=5f7c80a33273c5e53a317089a60f72cc) Zusätzliche befindet sich auf der rechten Seite der Tab "Probleme", welcher eine Übersicht über alle Fehler der momentan bearbeiteten Datei bietet. Durch einen Doppelklick auf einen Eintrag in dieser Liste, kann direkt zur Stelle des Fehlers gesprungen werden. Zusätzlich zu Syntaxfehlern werden noch die folgenden Prüfungen durchgeführt: * Prüfung auf gültige Entitäts-, Feld- und Relationsnamen, sofern ein gültiges System für die Metadatenbeschaffung konfiguriert worden ist * Prüfung auf gültige Bibliotheksmethoden * Prüfung auf gültige Variablennamen ![image2022-8-1_8-27-49.png](https://help.cursor.de/__attachments/a_c79c14fbf0013df7dbad7b49666a2c71842e2522862468571395e5aceb45675c/image2022-8-1_8-27-49.png?cb=bffb5d3e16623da6806263a122accd58) ## Übersicht über alle Testschritte / Bibliotheksmethoden Für Testfälle und Testschrittbibliotheken bietet das Test-Studio eine Übersicht über alle definierten Testschritte, Variablen und Bibliotheksmethoden. Damit kann sich insbesondere in langen Testfällen und großen Testschrittbibliotheken ein Überblick verschafft werden. Diese Übersicht kann über das Kontextmenü des Editors unter dem Punkt "Übersicht öffnen (aktuelle Datei)" (Tastenkombination STRG + UMSCHALT ⇧ + O ) geöffnet werden. Die Übersicht ist filterbar und durch einen Doppelklick auf einen Eintrag kann zur jeweiligen Definition gesprungen werden. Als Alternative zum Doppelklick besteht die Möglichkeit das gewünschte Sprungziel mit den Pfeiltasten auszuwählen und mit der Entertaste zu bestätigen. ![image2022-8-1_8-47-45.png](https://help.cursor.de/__attachments/a_0f96ed30aaefd698421625d8ff9e0bd75b4eb207f72723f08effcd5cc1271c5f/image2022-8-1_8-47-45.png?cb=e1feeb5b70b948d12bf385a24e01781d) Um sich einen Überblick über den gesamten Workspace zu verschaffen, bietet das Test-Studio neben der Übersicht über einen Testfall oder eine Testschrittbibliothek eine Übersicht über sämtliche Testschritte, Variablen und Bibliotheksmethoden in gesamtem Workspace. Diese Übersicht über den gesamten Workspace kann über das Kontextmenü des Editors unter dem Punkt "Übersicht öffnen (Workspace)" (Tastenkombination STRG + UMSCHALT ⇧ + ALT + O ) geöffnet werden. Auch diese Ansicht ist filterbar und es kann mit einem Doppelklick zur jeweiligen Definition gesprungen werden. Bei einem Doppelklick auf einen Dateinamen wird diese im Editor geöffnet. ![image2022-8-1_8-57-19.png](https://help.cursor.de/__attachments/a_84ca93924fb51bb3b047e73640596d57d5dcfff1e5203b4488eadf34730c628a/image2022-8-1_8-57-19.png?cb=dc65d77cf151dff505893b92623b4394) ## Übersicht über Verwendungsstellen einer Bibliotheksmethode Ausgehend von der Definition einer Bibliotheksmethode kann über den Eintrag "Springe zu Referenzen" (Tastenkombination UMSCHALT ⇧ + F12 ) im Kontextmenü auf dem Bibliotheksnamen eine Übersicht über die Verwendungsstellen der Bibliotheksmethode geöffnet werden. Wie auch schon bei den vorherigen Übersichten kann per Doppelklick zur jeweiligen Verwendungsstelle navigiert werden. Zusätzlich gibt es für jede Verwendungsstelle eine kleine Vorschau, in welchem Kontext die Verwendung erfolgt. Falls nur eine Verwendungsstelle existiert, wird direkt zu dieser Stelle gesprungen. ![image2022-8-1_12-23-29.png](https://help.cursor.de/__attachments/a_6806bc1c39688ae6d0bde1d5a07ecc7a135175f810a87a04abaebd3945591f81/image2022-8-1_12-23-29.png?cb=79ba56b6fcfe33ad1d6cbe3258897950) ## Absprung zur Definition einer Bibliotheksmethode Ausgehend von einem Aufruf einer Bibliotheksmethode durch das `execute`-Keyword kann über den Eintrag "Springe zur Definition" (Tastenkombination UMSCHALT ⇧ + F12 ) im Kontextmenü auf dem Methodennamen zur Definition der aufgerufenen Bibliotheksmethode navigiert werden. ![image2022-8-1_12-23-16.png](https://help.cursor.de/__attachments/a_90e8bf3294f37eb610fd20bc95e11a7497315dad0a7d791a437c516d3ecfd800/image2022-8-1_12-23-16.png?cb=01a27da855a549b9a28f283f8f06d108) ## Umbenennung eines Testfalls / Testschrittbibliothek oder einer Bibliotheksmethode Eine Umbenennung eines Testfalls oder einer Testschrittbibliothek ist über den Eintrag "Umbenennen" über das Kontextmenü im Dateibaum möglich. Der Vorteil dieser Umbenennung im Vergleich zur Umbenennung über das Dateisystem ist bei Testschrittbibliotheken, dass automatisch alle Verwendungsstellen der umbenannten Testschrittbibliothek angepasst werden, sodass nicht manuell alle Testfälle geprüft werden müssen. Zu beachten ist, dass die Umbenennung nur möglich ist, wenn der gesamte Workspace keine Syntaxfehler enthält. ![image2022-8-1_9-21-7.png](https://help.cursor.de/__attachments/a_02bfbc68466fcbf82f4a3d42200102c2711390c390813b00077077b461d87065/image2022-8-1_9-21-7.png?cb=f162a8ddb6e2518f08399c702a2136d1) Eine Umbenennung einer einzelnen Bibliotheksmethode ist über den Eintrag "Umbenennen" im Kontextmenü (Taste F12 ) des Namen der Bibliotheksmethode möglich. Es öffnet sich ein Eingabefeld unterhalb des Bibliotheksnamens für die Eingabe des neuen Methodennamens. Mit der Entertaste wird der eingegebene neue Name bestätigt und die Umbenennung durchgeführt. Der Vorteil dieser editorgestützten Umbenennung ist im Vergleich zur manuellen Umbenennung in der Datei selbst, dass alle Verwendungsstellen dieser Bibliotheksmethode automatisch angepasst werden, sodass eine manuelle Nachbearbeitung aller Testfälle entfällt. Zu beachten ist, dass die Umbenennung ebenfalls nur möglich ist, wenn der gesamte Workspace keine Syntaxfehler enthält. ![image2022-8-1_9-19-9.png](https://help.cursor.de/__attachments/a_62375ea8fe0a48942b01236f5c438f08ba38d1e705a113d231e23216cb8ccd5c/image2022-8-1_9-19-9.png?cb=4084fe80c4916dfc39266548a5a0cef5) --- version: "current" language: "de" --- # Funktionsübersicht **Funktionen** * [Interaktiver Modus](https://help.cursor.de/de/tstudio/current/interaktiver-modus.md) * [Editorfunktionen des Test-Studios](https://help.cursor.de/de/tstudio/current/editorfunktionen-des-test-studios.md) * [Protokollansicht](https://help.cursor.de/de/tstudio/current/protokollansicht.md) * [Keywords](https://help.cursor.de/de/tstudio/current/keywords.md) * [Nutzerwechsel im Test-Studio](https://help.cursor.de/de/tstudio/current/nutzerwechsel-im-test-studio.md) * [Verwendung von Variablen in Testfällen](https://help.cursor.de/de/tstudio/current/verwendung-von-variablen-in-testfallen.md) * [Sperrkonzept Workspace](https://help.cursor.de/de/tstudio/current/sperrkonzept-workspace.md) * [Testschrittbibliothek](https://help.cursor.de/de/tstudio/current/testschrittbibliothek.md) * [Controlling der Testergebnisse im CRM](https://help.cursor.de/de/tstudio/current/controlling-der-testergebnisse-im-crm.md) * [Relative Datumsangaben](https://help.cursor.de/de/tstudio/current/relative-datumsangaben.md) ![Funktionen.svg](https://help.cursor.de/__attachments/a_cf2924c7b6926d6d2f5d29a368e5111da40228d4b250e242cdad31236d2f91b5/Funktionen.svg?cb=bb344060a4d2d0546bee05cddeff5e81) ## Allgemeine Funktionen Mit dem CURSOR Test-Studio können automatisierte Oberflächentests ausgeführt werden. Dabei werden in der aktuellen Version folgende Funktionen unterstützt. * Masken benutzen * Felder füllen und prüfen * Buttons/Schalter anklicken * Texte prüfen * Auswählen von Einträgen in einer Liste * Suchen ausführen und mit dem Ergebnis arbeiten * Alle BPM-Benutzer-Aktionen: Suchen, Meldungen, Masken, Ausleihen von Dokumenten etc. * Speicherung von Tests * Protokollierung inkl. Screenshots und detaillierter Fehlermeldungen (Stack-Traces) * Übergabe der Protokolle an CURSOR-CRM/EVI/TINA * Navigation über den Unterbereich ## Browser-Verfügbarkeit Das Test-Studio kann in 3 Webbrowsern ausgeführt werden. * **Google Chrome** * **Mozilla Firefox** * **Microsoft Edge** * Nur der Chromium-basierte Edge * Kann normal in den Einstellungen ausgewählt werden * WebDriver-Updater im Einstellungsmenü * ![warning](https://help.cursor.de/__attachments/a_8115f0b735e1176679ea066c60adf519b379e6fdc23d1b639e85b0b3a68ffb68/atlassian-warning?cb=14432459925d605e05cae2605cdfe666) [Die Telemetriefunktion des EdgeDrivers](https://docs.microsoft.com/en-us/microsoft-edge/webdriver-chromium/?tabs=java#opt-out-of-diagnostic-data-collection)wird immer deaktiviert. --- version: "current" language: "de" --- # Grundlegendes Konzept ## Warum sollte ich automatisch testen? Testen ist ein wichtiger Bestandteil zur Qualitätssicherung in der Softwareentwicklung. Besonderer "Bedarf" für Qualitätssicherung entsteht dabei immer nach Anpassungen an einem System, z.B. * Funktionieren alle Prozesse nach einem großen Versionsupdate noch? * Habe ich durch meine individuellen Anpassungen (C2-Customizing) vielleicht andere Bereiche im CRM "beschädigt"? * Funktionieren nach einem Versions- oder Modul-Update meine systemspezifischen Anpassungen (C2-Customizing) noch? * Regelmäßiges Testen, um frühzeitig Probleme zu erkennen -- alles, was nicht durch den Endanwender gemeldet wird, ist ein Gewinn! Selbst bei einfachen Systemen ist es ermüdend, alles manuell zu testen. Umfangreiche und kritische Systeme (und dazu zählen insbesondere CRM-Systeme) sollten umfassend getestet werden. Automatisierung ermöglicht es, den Aufwand in Grenzen zu halten ("Der Test muss nur einmal geschrieben werden (zeitaufwendig) und kann beliebig oft ausgeführt werden (kaum manueller Zeitaufwand)". Aber auch Tests unterliegen gewissen Einschränkungen. Sicher ist es nicht erstrebenswert oder möglich, alles zu automatisieren: Integration und Schnittstellen mit Drittsystemen können nicht mit vertretbarem Aufwand automatisch getestet werden. Dafür bieten sich "halb-automatische Tests" an: Alle CRM-Aktionen sind automatisiert, die Aktionen im anderen System werden vom Testausführenden selbst abgearbeitet. Nicht zuletzt ist ein Testfall mit dem Test-Studio eine "ausführbare Dokumentation": Er ist automatisch ausführbar, aber dennoch leicht zu verstehen. So haben Sie immer eine aktuelle Dokumentation, auf der Sie aufbauen können! ## Wo teste ich? Tests können prinzipiell auf jedem CRM-System ausgeführt werden, sinnvoll ist dies jedoch nur bei zwei: | **System** | **Ausführung von Tests** | **Welchen Zweck erfüllen die Tests?** | |------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Entwicklungssystem | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | Sicherstellung des Funktionsumfangs meiner Customizing-Anpassungen. Das Paket muss nicht zur fachlichen Abnahme ins Testsystem transportiert werden, wenn es noch gar nicht technisch funktioniert. | | Testsystem / QS-System | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | Regressions- und Abnahmetests: * Funktionieren meine Customizing-Änderungen wie erwartet? * Wurden Fehler in anderen Bereichen eingeführt? (z.B. durch Anpassungen an einer Skript-Bibliothek, die an mehreren Stellen verwendet wird oder BPM-Teilprozessen) | | Produktivsystem | ![cross mark](https://help.cursor.de/__attachments/a_9053c4cbeb649cfcfd64d2d4e49dbd348bb3c6f45a1fc63d36024b2ceb2cef89/atlassian-cross_mark?cb=a9c671cfc7809253be52d640dbbf1019) | Keine Notwendigkeit für funktionale Tests, da bereits in den vorgelagerten Systemen getestet wurde. | ## Welche Anforderungen an Testfälle gibt es? * Testfälle sollten autark funktionieren und sich nicht darauf verlassen, dass andere Testfälle vor ihnen korrekt ausgeführt wurden. Die Ausführungsreihenfolge der Tests kann nicht festgelegt werden. * Sie raten nicht über den Zustand der Anwendung. Im Test weiß man immer genau, welche Aktionen man bereits ausgeführt hat und was das erwartete Verhalten der Anwendung ist. * Sie können mehrmals hintereinander ausgeführt werden, ohne dadurch auf Fehler zu laufen. * Test verhalten sich deterministisch und müssen im Fehlerfall auch einen Fehler ausgeben. * Sie werden nicht solange wiederholt, bis sie erfolgreich gelaufen sind. "Wackel-Tests" müssen entweder im Customizing des CRMs oder im Test repariert werden. * Testfälle sind möglichst kurz zu halten. Der Test sollte wirklich nur die Aktionen ausführen, die auch für den Test notwendig sind und genau eine fachliche Nachbedingung testen. ## Wie sind Tests aufgebaut? Wir unterscheiden zwischen fünf Stufen: **Workspace**: Das Projekt (Verzeichnis), das alle Testfälle und Testschrittbibliotheken enthält. **Testsammlung**: Mehrere Testfälle, die einen engen Bezug haben, z.B. "Alle Testfälle für den Angebotsprozess". Siehe "Wie organisiere ich Testfälle?". **Testfall** : Ein zusammenhängender Testfall, z.B. "Angebotsprozess für Bestandskunden". Dieser besteht aus Testschritten. Eine detaillierte Einführung finden Sie in der [Anwenderdokumentation](https://help.cursor.de/de/tstudio/current/anwenderdokumentation.md). **Testschrittbibliothek**: Bietet die Möglichkeit Testmethoden anzulegen, die testfallübergreifend verwendet werden können. **Testschritt**: Sequenz aus Keywords, die einen einzelnen fachlich abgeschlossenenen Schritt darstellen. Bspw. "Wähle den Geschäftspartner aus". Im BPM Umfeld ergibt ein Testschritt pro BPM-Benutzer-Aktion meist Sinn. ## Wie organisiere ich Testfälle? Jeder Testfall ist eine eigene Datei. Mehrere Testfälle, die fachlich eng verbunden sind (z.B. alle Testfälle für den Angebotsprozess) können in einer gemeinsamen Testsammlung abgelegt werden. Mehrere Hierarchieebenen sind möglich. Alle Testsammlungen werden innerhalb eines Workspaces zusammengefasst und können mittels Testschrittbibliotheken erweitert werden. Bestenfalls gibt es einen Workspace pro System. ### **Beispielhafter Workspace** CRM_Tests (WorkSpace) |- lib | |- MeineTestBibliothek (Testschrittbibliothek) | |- ... |- tests | |- Bestandskunden (Testsammlung) | | |- Tarifänderung (Testsammlung) | | | |- Tariferhoehung.webtest (Testfall) | | | |- ... | | |- Umzug | | | |- Umzug_mit_Netzbetreiberwechsel.webtest | | | |- Umzug_ohne_Sonderkuendigungsrecht.webtest | | | |- ... | | |- ... | |- Neukunden | | |- Neukunde.webtest | |- ... Die Struktur der Testsammlungen bestimmt nicht die Reihenfolge in welcher die Tests ausgeführt werden. ## Keyword-Driven-Testing Das CURSOR Test-Studio verwendet das Prinzip des *Keyword-Driven-Testens* . Ein *Keyword* stellt eine (komplexere) Aktion dar, die im CRM durchgeführt werden kann ("Speichere den Datensatz", "Fülle dieses Nachschlagefeld durch Suchen mit den Kriterien X und Y"). Diese Abstraktion ermöglicht ein schnelles Schreiben der Tests, da auf einer fachlichen Ebene gearbeitet wird, die der Arbeitsweise eines Menschen ähnelt. Keywords sorgen außerdem für robuste Tests, denn das Keyword zum Speichern des Datensatzes wird immer funktionieren: Sollte der Schalter *Speichern* aus der Symbolleiste ein anderes Icon erhalten oder sich die Oberfläche des CRMs ändern, funktioniert das Keyword weiterhin und der Test muss nicht angepasst werden. ## Vorgehensweise des Test-Studios ### Testausführung Während der Testausführung verhält sich das Test-Studio wie ein Anwender. Dies bedeutet, dass das Test-Studio bedient den Web Client "wie ein Mensch" und befolgt dabei strikte Anweisungen. Variable Eingaben wie "Wenn Ereignis A eintritt, dann führe als nächstes Anweisung A aus, ansonsten Anweisung B" sind nicht möglich. Das Test-Studio ist immer an einen zuvor definierten Weg ohne mögliche Weichen gebunden. Dies dient der Übersichtlichkeit der Testergebnisse und sichert eine langfristig wartbare Test-Suite. Um mehrere Wege abzubilden sollten auch mehrere Testfälle erstellt werden. ### Testfallerstellung Die Testfallerstellung erfolgt analog der Ausführung in der Anwenderperspektive und kann grundsätzlich ohne Einblicke in die Umsetzung des Customizings erfolgen (Beispiele: technisches Modell von BPM-Prozessen, Implementierung von Skriptbibliotheken und Maskenskript). Für die sogenannten Black-Box-Tests kann bspw. die Anwenderdokumentation eines Prozesses als Grundlage für die Testfallerstellung verwendet werden. Somit können Test-Studio-Tests auch durch Nicht-Entwickler wie bspw. fachlich verantwortliche Personen erstellt werden. Soll tiefergehende Logik getestet werden, empfiehlt es sich, einen Blick in die Umsetzung des Customizings zu werfen und die dort implementierte Logik bei der Erstellung des Testfalls zu berückichtigen (Beispiele: Standardwerte, berechnete Felder). Diese White-Box-Tests setzen somit eine Zusammenarbeit mit einem Ansprechpartner voraus, welcher das Customizing einsehen und verstehen kann. Je nach Testverfahren gibt es zahlreiche Punkte, die getestet werden können, bspw.: * Randfälle prüfen (Leere Eingaben, "kreative" Eingaben) * Sowohl negative als auch positive Fälle testen (letztere werden beim manuellen Testen meist bevorzugt) * Verzweigungen und Entscheidungen prüfen. Dabei ist zu beachten, dass der Test mit dem ersten Fehlerzustand beendet wird. Der nachfolgende Code wird nicht ausgeführt. Zu viele Bedingungen innerhalb des selbsten Testfalls abzudecken kann somit dazu führen, dass einige davon nicht getestet werden. ## Testdaten Der Test ist selbst dafür verantwortlich, seine benötigten Testdaten anzulegen oder zu identifizieren, damit mit diesen Daten gearbeitet werden kann und sie auch hinterher ggf. wieder zu löschen. Testdaten können auf verschiedene Arten für das Test-Studio bereit gestellt werden. Für Funktionalitäten, die Datensätze nicht verändern, sondern lediglich verwenden, können dedizierte Testdatensätze im zu testenden System angelegt werden. Hierbei ist zu beachten, dass die Tests dann auch nur in Kombination mit den vorhandenen Testdatensätzen fehlerfrei durchlaufen können. Hierbei besteht die Gefahr, dass die Testdatensätze von anderen Anwendern oder Testfällen verändert werden und die Tests dann nicht mehr mit den erwarteten Daten arbeiten und somit irrtümliche Fehlerzustände aufgezeigt werden können. Diese irrtümlichen Fehlerzustände werden durch fehlerhafte Testdaten und nicht durch fehlerhaftes Customizing verursacht. Eine weitere Möglichkeit bietet die Anlage der Testdatensätze über einen BPM-Prozess. Dieser kann durch das Test-Studio gestartet werden. Datensätze können somit deutlich schneller angelegt werden. Außerdem wird der Testfall dadurch enorm verkleinert, so dass nur noch die Punkte durchlaufen werden, die testrelevant sind. BPM-Prozesse können außerdem verwendet werden um Testdaten zu entfernen oder um sie auf einen definierten Zustand zurück zu setzen. Selbstverständlich kann auch das Test-Studio zur Anlage von Testdaten verwendet werden. Hierbei ist zu beachten, dass die Testfälle dadurch ggf. stark vergrößert werden und dadurch auch Stellen in den Tests enthalten sind, die nicht das eigentlich zu testenden Custmizing sind. Außerdem wird es hierbei mit großer Wahrscheinlichkeit einige Redundanzen geben. Dies ist die langsamste Variante um Testdaten anzulegen. ## Grenzen von Oberflächentests Von CURSOR bereitgestellte Features werden sehr ausführlich und kontinuierlich getestet. Wird das Test-Studio in einem kundenindividuellen System genutzt, so können diese Standardfunktionalitäten vernachlässigt werden. Die Oberflächentest sollten sich ausschließlich auf die individuellen Umsetzungen (C2) konzentrieren. Es ist nicht immer sinnvoll, alles über die Oberfläche zu testen. Der Test eines Features kann durch eine andere Testart sinnvoller und schneller sein. ### Exkurs Unit-Tests (Skript-Bibliothek) In der Skript-Bibliothek gibt es die Möglichkeit, Unit-Tests zu einzelnen Methoden zu schreiben. In Ergänzung zu Oberflächentests sind diese eine sehr gute Wahl um Hintergrundaktionen oder Berechnungen zu testen. Sie haben eine sehr geringe Laufzeit (häufig im Millisekundenbereich) und hinterlassen keine Testdaten, da sie mit Transaction Rollback arbeiten. Anwendungsfälle für Unit-Tests sind bspw. komplexere Berechnungen oder Logiken, die gegen ein erwartetes Ergebnis geprüft werden. Mittels Unit-Tests lassen sich keine Oberflächen bedienen. Weitere Informationen können im Artikel [Skriptbibliothek](https://help.cursor.de/de/admin/current/skriptbibliothek.md#Testfall) nachgelesen werden. --- version: "current" language: "de" --- # Häufig gestellte Fragen (FAQs) ## You've got questions? We've got answers! Hier finden Sie alle Antworten auf häufig gestellte Fragen. ![FAQs.svg](https://help.cursor.de/__attachments/a_2bbe967227e7eb448161f6b6f07e008bf797516c7ff351c8d43d550122b6ee3d/FAQs.svg?cb=13b1a136333be22471a067791cd291cc) Inwieweit unterscheidet sich das Test-Studio von 3rd-Party-Testsuites? Das Studio ist so weit auf den CURSOR Web-Client zugeschnitten, dass für die Testfallerstellung keine Webentwicklerfähigkeiten benötigt werden. Um einen Testfall zu erstellen müssen lediglich sprechende Keywords aneinander gereiht werden. Somit kann beispielsweise auch eine Fachabteilung mit einer kleinen Einführung eigenständig Testfälle erstellen. Mit welchen Produkten ist das Test-Studio kompatibel? Alle CURSOR Web Clients (CRM, EVI, TINA) können mit dem Studio bedient werden. Seltsames Verhalten, manche Felder werden nicht gefunden oder die Tabellenselektion greift im Unterbereich nicht richtig. Durch den Zen-Modus und den Onboarding-Assistenten wird ggf. der sichtbare Bereich der Maske automatisch angepasst. Daher sind beide für den Test-Benutzer zu deaktivieren. Wie wirkt sich der in den Einstellungen festgelegte Time-Out aus? Der hinterlegte Wert ist die maximale Wartezeit, ab wann ein Time-Out eintritt. Ist hier bspw. `10`eingetragen, so wartet das Test-Studio bis zu 10 Sekunden. Wird innerhalb dieser Zeit der gewünschte Systemzustand nicht erreicht, so wird ein Time-Out ausgelöst, der Testfall abgebrochen und ein entsprechender Protokolleintrag geschrieben. Das bedeutet, wird ein erwarteter Systemzustand schon vor den 10 Sekunden erreicht, wird auch keine 10 Sekunden gewartet. Was unterscheidet das CURSOR Test-Studio von anderen UI-Test-Tools? * **Keine Programmierkenntnisse**erforderlich. Testfälle bestehen aus einer Aneinanderreihung von Benutzeraktionen und sind leicht verständlich. * **Stabiles Warten**, bis der WebClient für die nächste Aktion bereit ist: Wir fragen beim WC nach, ob er bereit ist. Andere können oft nur warten, bis eine Komponente da ist oder eine feste Zeitspanne verstreichen lassen. * **Stabile Selektoren**: Die Keywords stellen eine höhere Abstraktionsschicht von Selektoren dar und sind damit deutlich stabiler gegenüber technischen Veränderungen als andere Test-Tools. * Im **übersichtlichen Report**werden die ausgeführten Keywords geloggt, so ist auf den ersten Blick erkennbar, welche Aktionen durchgeführt wurden. Im Fehlerfall werden technische Details für die Fehleranalyse protokolliert. * **Integration in die CURSOR-Landschaft**: Test-Studio und CRM ergänzen sich perfekt. Bei der Testerstellung wird der Anwender durch kontextbezogene Vorschläge, die auf das eigene System abgestimmt sind, unterstützt. Außerdem werden die Testergebnisse in das CRM synchronisiert und können sehr einfach mit Boardmitteln grafisch aufbereitet werden. --- version: "current" language: "de" --- # Installation und Update ## Einleitung Das Test-Studio unterstützt Customizing-Arbeiten im CRM durch reproduzierbare Tests. Damit diese maximalen Nutzen generieren, ist es notwendig, diese regelmäßig, automatisiert auszuführen und die Ergebnisse ansprechend zugänglich zu machen. Dieses Dokument beschreibt eine solche Umgebung. ## Systemlandschaft für das Test-Studio **Verschiedene Benutzer** In dieser Anleitung sind -- sofern nicht anders dargestellt -- alle Benutzer stets Windows-(Domänen)-Accounts. Ein optimales Deployment des Test-Studios sieht wie folgt aus: ![Deployment_Large.drawio.svg](https://help.cursor.de/__attachments/a_7a51ed797d0f6f7210bf40eff5f1bf13b524f71ec61736b4a855af54b31132b4/Deployment_Large.drawio.svg?cb=465b0d8a2850f8312fcb7791244e9b06) **Legende** * Kanten mit `Datei: ...` beziehen sich auf Dateirechte. * Kanten mit `CRM: ...` beziehen sich auf CRM-(Aktions-)Rechte ### Benutzer und Server * In der Regel wird `TestMaintainer` das Test-Studio auf seinem lokalen PC ausführen; eine Nutzung in "Terminalserversitzungen" (Windows Remote Desktop Services (RDS) -- server session-based desktops) ist prinzipiell möglich. * Die regelmäßige Testausführung sollte mit einem separaten Benutzer (hier `TestExecutor` ) auf einem separaten (Windows-)System passieren. Dieser Nutzer sollte mit minimalen Rechten ausgestattet werden. * Die gestrichelten Kanten vom `TestMaintainer` zu `\\sReport\report` sind optional, wenn die CRM-Rückführung nur für die nächtlichen Testläufe genutzt werden soll. * Der Installationspfad des Test-Studios und ggf. die WebDriver muss auf allen Systemen, auf denen Tests ausgeführt bzw. bearbeitet werden sollen, unter einem Laufwerksbuchstaben verfügbar sein; ein UNC-Pfad ist nicht geeignet. #### CRM-Systeme Die Tests werden auf dem "Test CRM" ausgeführt, in das "Report CRM" werden -- sofern konfiguriert -- die Ergebnisse hinterlegt. Diese Systeme können identisch sein; für die Testausführung und das Speichern der Ergebnisse können unterschiedliche CRM-Benutzer verwendet werden. Für das Test-CRM ist ein CRM-Benutzer mit folgenden Eigenschaften anzulegen: * Dessen Konfiguration (u.a. Rechte, Konfigurationsgruppe, Benutzereinstellungen, Mitarbeiterdatensatz) bestimmt die "Umgebung", in der die Tests ausgeführt werden. * Das Aktionsrecht "GUI-Testfälle ausführen" muss gewährt werden. * Für den ausführenden Benutzer müssen zwingend Zen-Modus und Onboarding-Assistent deaktiviert sein. * Das Modul "Test-Studio" muss lizenziert sein. Während der Testlauf durchgeführt wird, darf der verwendete CRM-User nicht über weitere Wege im System tätig sein, da dies zu Fehlern führen kann. ### Übersicht über benutzte Pfade und benötigte Dateirechte | Ort | Erklärung | Rechte für Nutzer **TestMaintainer** ||| Rechte für Nutzer **TestExecutor** ||| | Ort | Erklärung | Lesen | Schreiben | Ausführen | Lesen | Schreiben | Ausführen | |-----------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------| | `\\sReport\report` | Verzeichnis, in das Reports und Screenshots geschrieben werden, die für die Testergebnisse im Report-CRM benötigt werden. In das Report-CRM wird nur eine Zusammenfassung der Testergebnisse ("Welcher Schritt mit welchem Keyword hat nicht funktioniert?") geschrieben, aber keine Details ("Welche Keywords wurden alles ausgeführt?"). Diese Informationen werden in einem detaillierten Report (Datei mit Endung `teststudio_log`) gespeichert. Diese wird im Report-CRM als LINK-Dokumentendatensatz referenziert. | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) / ![cross mark](https://help.cursor.de/__attachments/a_9053c4cbeb649cfcfd64d2d4e49dbd348bb3c6f45a1fc63d36024b2ceb2cef89/atlassian-cross_mark?cb=a9c671cfc7809253be52d640dbbf1019) | ![cross mark](https://help.cursor.de/__attachments/a_9053c4cbeb649cfcfd64d2d4e49dbd348bb3c6f45a1fc63d36024b2ceb2cef89/atlassian-cross_mark?cb=a9c671cfc7809253be52d640dbbf1019) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![cross mark](https://help.cursor.de/__attachments/a_9053c4cbeb649cfcfd64d2d4e49dbd348bb3c6f45a1fc63d36024b2ceb2cef89/atlassian-cross_mark?cb=a9c671cfc7809253be52d640dbbf1019) | | `\\sWorkspace\test` | Verzeichnis, das den Workspace mit allen Testfällen und Testschrittbibliotheken enthält. Testfälle können in (beliebig tief verschachtelte) Unterordner sortiert werden. | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![cross mark](https://help.cursor.de/__attachments/a_9053c4cbeb649cfcfd64d2d4e49dbd348bb3c6f45a1fc63d36024b2ceb2cef89/atlassian-cross_mark?cb=a9c671cfc7809253be52d640dbbf1019) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![cross mark](https://help.cursor.de/__attachments/a_9053c4cbeb649cfcfd64d2d4e49dbd348bb3c6f45a1fc63d36024b2ceb2cef89/atlassian-cross_mark?cb=a9c671cfc7809253be52d640dbbf1019) | ![cross mark](https://help.cursor.de/__attachments/a_9053c4cbeb649cfcfd64d2d4e49dbd348bb3c6f45a1fc63d36024b2ceb2cef89/atlassian-cross_mark?cb=a9c671cfc7809253be52d640dbbf1019) | | `\Client\jboss\teststudio` | Installationsverzeichnis des Test-Studios. Enthält grundlegende Konfiguration (u.a. Truststore). | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![cross mark](https://help.cursor.de/__attachments/a_9053c4cbeb649cfcfd64d2d4e49dbd348bb3c6f45a1fc63d36024b2ceb2cef89/atlassian-cross_mark?cb=a9c671cfc7809253be52d640dbbf1019) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![cross mark](https://help.cursor.de/__attachments/a_9053c4cbeb649cfcfd64d2d4e49dbd348bb3c6f45a1fc63d36024b2ceb2cef89/atlassian-cross_mark?cb=a9c671cfc7809253be52d640dbbf1019) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | | `\\sInstall\testStudio\webDriver` | Enthält die WebDriver, wenn sie zentral bereitgestellt werden sollen. Das ist zu empfehlen, weil dies ausführbare Dateien sind und zum anderen die Wartbarkeit verbessert wird. | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![cross mark](https://help.cursor.de/__attachments/a_9053c4cbeb649cfcfd64d2d4e49dbd348bb3c6f45a1fc63d36024b2ceb2cef89/atlassian-cross_mark?cb=a9c671cfc7809253be52d640dbbf1019) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![cross mark](https://help.cursor.de/__attachments/a_9053c4cbeb649cfcfd64d2d4e49dbd348bb3c6f45a1fc63d36024b2ceb2cef89/atlassian-cross_mark?cb=a9c671cfc7809253be52d640dbbf1019) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | | `%WORKING_DIR%` | Ein lokales Arbeitsverzeichnis pro Test-Studio Benutzer zur Ablage von Screenshots, Einstellungen und Protokollen. | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![cross mark](https://help.cursor.de/__attachments/a_9053c4cbeb649cfcfd64d2d4e49dbd348bb3c6f45a1fc63d36024b2ceb2cef89/atlassian-cross_mark?cb=a9c671cfc7809253be52d640dbbf1019) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![check mark](https://help.cursor.de/__attachments/a_271a7260881494808e0b518c2fc424c85f742ecc2a6b1b358a4298f430cea5c3/atlassian-check_mark?cb=a10212e1c1021c5194f7535b6843f955) | ![cross mark](https://help.cursor.de/__attachments/a_9053c4cbeb649cfcfd64d2d4e49dbd348bb3c6f45a1fc63d36024b2ceb2cef89/atlassian-cross_mark?cb=a9c671cfc7809253be52d640dbbf1019) | ### Sicherheitsbetrachtungen * Die Test-Studio Sprache basiert auf groovy, d.h. Testfälle können theoretisch beliebigen Code enthalten, der während der Testausführung zur Ausführung kommt. Damit könnte der Testersteller (`TestMaintainer`) (theoretisch) beliebigen Code im Kontext des Nutzers `TestExecutor` ausführen. Das Einfügen belieben Codes in Testfällen wird von CURSOR nicht unterstützt. * Deshalb sollte `TestExecutor` mit minimalen Rechten ausgestattet sein. * Die vom Test-Studio gestartete WebDriver (vgl. [Technischer Kommunikationsplan der CURSOR-Test-Studio Komponenten](https://help.cursor.de/de/tstudio/current/technischer-kommunikationsplan-der-cursor-test-stu.md)) horchen auf dem loopback Interface auf ihre Befehle, die der Browser ausführt. Siehe , diese Empfehlungen gelten ebenso für GeckoDriver (Firefox) und EdgeDriver (Microsoft Edge). * Die WebDriver können über das Test-Studio automatisch aktualisiert werden (vgl. [Technischer Kommunikationsplan der CURSOR-Test-Studio Komponenten](https://help.cursor.de/de/tstudio/current/technischer-kommunikationsplan-der-cursor-test-stu.md)). Diese Funktion lädt Programmkomponenten aus dem Internet herunter. ### Einrichten der Dateityp-Verknüpfungen Die Test-Studio Reports werden als Dateien mit der Endung `.teststudio_log` gespeichert. Dieser Dateityp sollte mit den Test-Studio registriert werden, damit sie aus dem Report CRM direkt geöffnet werden können (dort sind sie nur als LINK-Dokumente hinterlegt). #### Registrieren mittels `.reg` -Datei Über das Test-Studio kann eine `.reg`-Datei über "Einstellungen -\> Verknüpfung von .teststudio.log Dateien mit dem Test-Studio" im Test-Studio für die Dateityp-Verknüpfung erzeugt werden. Diese muss anschließend importiert bzw. per Client-Management-Lösung (z.B. Gruppenrichtlinie) verteilt werden. ## Update **Verteilung des Test-Studios mittels Windows-Client** Das Test-Studio wird mit dem Windows-Client ("Rich-Client") verteilt, so wird es im Rahmen der normalen CRM-Patchtes ebenfalls aktualisiert. Bis auf `configuration.bat` und eigene weitere Dateien werden alle Dateien im Verzeichnis des Studios ausgetauscht. Wird der Rich-Client nicht mittels Client-Update-Tool verteilt, so muss das Test-Studio nach jedem Update oder Patch des CRMs anderweitig aktualisiert werden. ## WebDriver und Browser Das Test-Studio unterstützt die Browser * Microsoft Edge, * Google Chrome, * Mozilla Firefox. Um mit diesen kommunizieren zu können, benötigt das Test-Studio einen WebDriver (vgl. [Technischer Kommunikationsplan der CURSOR-Test-Studio Komponenten](https://help.cursor.de/de/tstudio/current/technischer-kommunikationsplan-der-cursor-test-stu.md)). Dieser WebDriver ist browserspezifisch und ggf. abhängig von der Version des Browsers: * Microsoft Edge und Google Chrome benötigen einen WebDriver in der derselben Version wie die Hauptversion des Browsers. Ein älterer WebDriver funktioniert in der Regel übergangsweise; es treten aber sehr schnell Probleme auf. Durch die hohe Updatefrequenz der Browser muss auch der WebDriver entsprechend häufig aktualisiert werden. * Der von Mozilla Firefox benötigte WebDriver arbeitet i.d.R. versionübergreifend, d.h. ein älterer WebDriver kann trotzdem einen neueren Firefox fernsteuern. Das sollte berücksichtigt werden, wenn bspw. der Browser über eine zentrale Softwareverteilung automatisch aktualisiert wird. ### Speicherort des WebDrivers Standardmäßig wird der WebDriver im %WORKING_DIR% abgelegt, das in der configuration.bat hinterlegt ist. Dabei erwartet das Test-Studio folgende Namenskonvention: |-------------------------|--------------------------------------| | **Verwendeter Browser** | **Pfad des WebDrivers** | | Microsoft Edge | %WORKING_DIR%\\webdriver_edge.exe | | Mozilla Firefox | %WORKING_DIR%\\webdriver_firefox.exe | | Google Chrome | %WORKING_DIR%\\webdriver_chrome.exe | Die Pfade können in der configuration.bat durch Aufnahme folgender Zeilen angepasst werden SET TESTSTUDIO_ENGINE_DRIVER_CHROME=C:\my\chromedriver.exe SET TESTSTUDIO_ENGINE_DRIVER_FIREFOX=C:\my\geckodriver.exe SET TESTSTUDIO_ENGINE_DRIVER_EDGE=C:\my\edgedriver.exe Alternativ kann die Konfiguration auch über die [Administrative Vorgabe von Einstellungen](https://help.cursor.de/de/tstudio/current/administrative-vorgabe-von-einstellungen.md) erfolgen. ### Automatisches Herunterladen des WebDrivers * Über das "WebDriver" Menü im Einstellungsdialog wird der aktuellste WebDriver heruntergeladen und für die Verwendung konfiguriert. ### Manuelles Herunterladen des WebDrivers Abhängig vom verwendeten Browser, ist der WebDriver herunterzuladen und zu entpacken: * Microsoft Edge: * Google Chrome: ![info](https://help.cursor.de/__attachments/a_e97631208f1da053cf024e9c0d34af352f4c304a896338d9a4c586016e37a615/atlassian-info?cb=feab5cd71111204d6b52545f3027dd0c) Auf der Seite gibt es sowohl das Binary „chrome" für die Plattform „win32", wie auch „chromedriver". Nur das zweite Binary „chromedriver" ist richtig! * Mozilla Firefox: Die Pfade, an denen der WebDriver gepeichert werden muss, sind unter [Speicherort des WebDrivers](https://cursorhelp.atlassian.net/wiki/spaces/TSTUDIO/pages/edit-v2/38174751#Speicherort-des-WebDrivers) beschrieben. ## Regelmäßiges Ausführen der Tests Siehe [Regelmäßiges Ausführen der Tests](https://help.cursor.de/de/tstudio/current/regelmaiges-ausfuhren-der-tests.md) . ## Bekannte Einschränkungen * Die Bereitstellung des Test-Studios als Remoteanwendung (bspw. als RemoteApp aus Windows Remote Desktop Services (RDS)) wird nicht unterstützt. Das Test-Studio startet unter anderem den Browser zur Testausführung als untergeordneten Prozess ("child processes"). Das Browserfenster muss dem Testersteller für eine effiziente Testerstellung aber zugänglich sein. * Das Test-Studio wird nicht als Software-as-a-Service bereitgestellt. Das bedeutet, dass auch CRM-SaaS-Kunden das Test-Studio "lokal" installieren müssen. ## Technische Hintergrundinformationen * Das Test-Studio speichert seine gesamte Konfiguration im `WORKING_DIR`, das in der `configuration.bat` eingestellt werden kann. Im Standard zeigt es auf `%APPDATA%\CURSOR\testStudio` * Alle Passwörter werden -- sofern sie gespeichert werden sollen -- maskiert bzw. verschleiert gespeichert. Das bedeutet, dass jeder, der Zugang zum Test-Studio hat, diese auslesen und benutzen kann. Es wird aber in einer für den Menschen nicht lesbaren Form gespeichert (z.B. `oPjZxZLQ2tFGeLFfb6IDHQ==`). * Alle Einstellungen (auch gespeicherte Passwörter) werden unter `%WORKING_DIR%\customSettings.properties` gespeichert. * Die WebDriver (Programme, die die Browser fernsteuern) liegen standardmäßig dort und müssen vom Test-Studio Benutzer ausgeführt werden können. * Der Ort der Log-Dateien kann über `%WORKING_DIR%\additionalLogConfig.xml `gesteuert werden. --- version: "current" language: "de" --- # Installation unter Linux ![Tux.svg](https://help.cursor.de/__attachments/a_43cc26ac21645e54a5c5450d1c73ebc4d01dab4c4ae64fcb283d6653ef322a93/Tux.svg?cb=8a6487c7872a9b825c8f2d4533067c6d) ## Einführung Die Empfehlungen aus [Installation und Update](https://help.cursor.de/de/tstudio/current/installation-und-update.md) gelten auch für Linux. Somit stellt dies lediglich eine Ergänzung dar. Das Test-Studio unterstützt unter Linux nur den Batch-Betrieb (Aktualisierungen von WebDrivers und Testausführung), aber keine Bearbeitung von Testfällen oder Betrachtung von Reports in der graphischen Oberfläche. Der Batch-Betrieb unterstützt headless-server, d.h. es ist kein X-Server (oder Wayland) erforderlich, um Tests ausführen zu können. ## Initiale Einrichtung und Konfiguration Nach dem Entpacken des zip-Archivs muss mittels `chmod +x *.bash` das executable-Flag auf allen Skripten gesetzt werden. Für den Batch-Betrieb wird empfohlen, das `WORKING_DIR` auf einen absoluten Pfad zu setzen, der unabhängig vom aktuellen (Unix-)User ist: ### configuration.conf Bash # ########################################################################### # # Begin of user configuration # ########################################################################### # Path to Java 17 x64 JAVA_HOME=/usr # Working directory used; e.g. webdrivers will be downloaded here. WORKING_DIR=/opt/teststudio/workingdir # default: ~/.cursor/testStudio # ########################################################################### # # End of user configuration # ########################################################################### # Enable remote debug on port 5005 (true); anything else will disable it DEBUG=false # Custom Opts if required, for example: # CUSTOM_OPTS='"-Dwebclient.guitest.coloredAjaxIndicator=true" "-DmyOtherProperty=value with spaces"' CUSTOM_OPTS= # If to true, the associated console window of the java runtime is shown. SHOW_CONSOLE=false # Admin override file path if required, for example: # ADMIN_CONFIG_OVERRIDE=$WORKING_DIR%/local_admin_override.properties ADMIN_CONFIG_OVERRIDE= Ausführen von `./CURSOR_Test-Studio.bash` , um das `WORKING_DIR` zu initialisieren. Danach Erstellen und Anpassen der Basis-Test-Studio-Einstellungen innerhalb des `WORKING_DIR` : ### $WORKING_DIR/customSettings.properties Groovy # Created during manual installation teststudio.customizing.username= teststudio.customizing.password= teststudio.customizing.url= teststudio.engine.browser=CHROME|FIREFOX|EDGE teststudio.engine.headless=true teststudio.engine.timeout.seconds=20 # Alle teststudio.integration Einstellungen sind optional, wenn keine Integration der Testergebnisse in ein CRM gewünscht ist. teststudio.integration.crm.username= teststudio.integration.crm.password= teststudio.integration.crm.url= teststudio.integration.shared.document.dir= # optional #teststudio.integration.shared.document.dir.as.accessible.path= **Das "Gemeinsame Verzeichnis für Reports"** Die Einstellung `teststudio.integration.shared.document.dir` entspricht dem "Gemeinsames Verzeichnis für die Reports, die ins CRM geschrieben werden" aus den Einstellungen in der graphischen Benutzeroberfläche. Allerdings können hier (gerade unter Linux) einige Probleme auftreten: Da die Report-Dateien als Dokumente vom Typ LINK in das CRM geschrieben werden, müssen diese aus Sicht des Anwenders (bzw. dessen Windows-PC) zugänglich sein. Typischerweise wird dies eine Netzwerkfreigabe sein (entweder als UNC-Pfad `\\myserver\myreports` oder als "Verbundenes Netzlaufwerk" mit einem Laufwerksbuchstaben). Diese Pfade sind unter Linux in der Regel nicht auflösbar, deshalb kann mittels `teststudio.integration.shared.document.dir.as.accessible.path `dasselbe Verzeichnis aus "Linux-Sicht" angegeben werden. Das Konzept ist identisch zum *Transferverzeichnis* der Massendatenserienbriefe, das im Administrations-Handbuch des CRM im Abschnitt "Serienbriefe auf dem Massendatenserver" beschrieben wird. Beispiel: Verzeichnis `/opt/teststudio/reports` , das via SAMBA als SMB-Share unter `\\teststudioserver\reports` verfügbar gemacht wurde: * Das Test-Studio schreibt den Report der Testausführung in das Verzeichnis als `/opt/teststudio/reports/TESTSTUDIO_/report.teststudio_log` * Der Anwender öffnet den Report über den Dokumenten-Datensatz über `\\teststudioserver\reports\TESTSTUDIO_/report.teststudio_log` Diese Szenario kann über folgende Konfiguration abgebildet werden: teststudio.integration.shared.document.dir=\\\\teststudioserver\\reports #teststudio.integration.shared.document.dir.as.accessible.path=/opt/teststudio/reports Bei den Pfadangaben ist ein `\` als `\\` zu schreiben **Maskiertes Passwort erstellen** In der `customSettings.properties` muss das Passwort als "Verschleiertes Passwort" angegeben werden: Dieses kann in einem beliebigen Test-Studio aus dem Klartext-Passwort erzeugt werden. ![image-20231122-174605.png](https://help.cursor.de/__attachments/a_f83b67569da303a5e6d9ec789022937a29246528c79544f756cc1e60acbd7bd7/image-20231122-174605.png?cb=8d7103303711896b107b2d1c5dc3ee0b) Abschließend muss noch der passende WebDriver heruntergeladen werden: `./CURSOR_Test-Studio_batch update-driver`. ### TrustStore Sollte ein eigener TrustStore erforderlich sein, muss dieser in der Datei `truststore.conf` im Installationsordner hinterlegt werden: TRUSTSTORE_PATH=/path/to/jboss/truststore.p12 TRUSTSTORE_PASSWORD=cursor | **Gruppe** | **Name der Einstellung** | **Beschreibung** | |------------|--------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Truststore | Pfad | Pfad zum Truststore, der Public-Zertifikate enthält. Empfohlen ist, denselben Truststore wie der Windows-Client (Rich-Client) zu verwenden. (Die genaue Konfiguration kann der `configuration.conf` im Windows-Client Verzeichnis entnommen werden). **Zertifikate im Browser** Diese Konfiguration stellt keine Vertrauensstellung zwischen Server und Webbrowser (Google Chrome, Mozilla Firefox oder Microsoft Edge) her. Diese muss separat erfolgen -- das ist aber bereits der Fall, wenn normal mit dem Web-Client gearbeitet wird. | | Truststore | Passwort | Passwort für oben genannte Datei. Dieses Passwort schützt **keine schützenswerten** Informationen, sondern wird von Java technisch erzwungen: "Eine Truststore-Datei benötigt ein Passwort." | ## Regelmäßige Ausführung der Tests Für die regelmäßige Ausführung werden `systemd units` unter `systemd` bereitgestellt. Nach der Anpassung erfolgt die Installation durch Kopieren nach `/usr/local/lib/systemd/system/` . Der dort konfigurierte User muss über ein beschreibbares Home-Verzeichnis verfügen. (Insbesondere sind über useradd --no-create-home erstellte User ungeeignet). Die Timer müssen mittels Bash systemctl enable teststudio-execute-tests.timer systemctl start teststudio-execute-tests.timer bzw. Bash systemctl enable teststudio-update-driver.timer systemctl start teststudio-update-driver.timer aktiviert werden und können mit `systemctl list-timers` kontrolliert werden. ## Updates des Test-Studios Da das Client-Update-Tool nicht unter Linux verfügbar ist, muss das Test-Studio nach jedem Update oder Patch des CRMs manuell bzw. aktualisiert werden. --- version: "current" language: "de" --- # Interaktiver Modus ## Motivation Das Schreiben längerer Testfälle kann schnell zeitaufwendig werden. Daher wurde der sogenannte *interaktive Modus* eingeführt, mit dem Tests viel schneller geschrieben werden können, da einzelne Keywords direkt ausprobiert werden können. Das vollständige Ausführen eines Testfalls ist nicht mehr zwingend notwendig, um die letzten Änderungen testen zu können. Variablen werden ebenfalls unterstützt -- sie sind jederzeit mitsamt ihrer aktuellen Werte einsehbar! ## Einführung In einem Testfall kann ein sogenannter *Breakpoint* (dt. *Haltepunkt* ) definiert werden. Dies ist immer ein Keyword und wird über die Zeilennummer bestimmt. Bei der nächsten Testausführung stoppt die Testausführung am *Breakpoint*, d.h. das Keyword in der Zeile wird nicht mehr ausgeführt. Beispiel: Java class InteractiveModeDemo extends BaseWebClientSpec { def "FirstTestStep"() { given: open entity "Activity" create dataset set field "Subject.Activity" to "Mein Betreff!" save dataset } } Wird in Zeile 8 ("`save dataset`") ein Breakpoint gesetzt, passiert bei der nächsten Testausführung folgendes: > Anmelden am WebClient > Ausführen der Keywords open entity "Activity" create dataset set field "Subject.Activity" to "Mein Betreff!" set field "ActTypeKey.Activity" to "ERINNERUNG" > Anhalten am Breakpoint und Wechsel in den interaktiven Modus Der Browser bleibt geöffnet und nun können einzelne oder mehrere Keywords markiert und ausgeführt werden. Beides zusammen eröffnet neue Möglichkeiten: * Manuelle Aktionen im Web Client, um beispielsweise Fehlerzustände zu bereinigen. Beispiel: In obigem Beispiel wurde das Pflichtfeld "Art der Aktivität" nicht gefüllt, beim Speichern mittels `save dataset` erscheint die Prüfung auf "Ungültige Feldwerte". Als Testentwickler kann ich einfach auf die Neuanlagemaske zurücknavigieren und meinen Testfall anpassen zu: Java class InteractiveModeDemo extends BaseWebClientSpec { def "FirstTestStep"() { given: open entity "Activity" create dataset set field "Subject.Activity" to "Mein Betreff!" set field "ActTypeKey.Activity" to "ERINNERUNG" // wurde hinzugefügt save dataset } } Und die beiden Keywords in Zeilen 8 und 9 markieren und ausführen. * Ändern von Variablenwerten und erneutes Ausführen der Tests. * Einfachere Fehlersuche, wenn Keywords fehlschlagen, die im interaktiven Modus ausgeführt wurden. ## Benutzeroberfläche Es wurde eine neue Toolbar eingeführt, die Aktionen rund um den interaktiven Modus steuert. Außerdem wurde das Protokoll in das Hauptfenster integriert, um den Arbeitsablauf beim Schreiben von Testfällen zu beschleunigen. ![image2022-11-3_9-50-10.png](https://help.cursor.de/__attachments/a_ac15fec40922c0fa6757b1ad48f1156cbf7bff8061179898e284dbc6d712096b/image2022-11-3_9-50-10.png?cb=1ecff6f023d609eaec521f87496737f9) | **Element** | **Beschreibung** | |------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Interaktiven Modus verlassen | Beendet den Browser und damit die aktuelle Testausführung. Im Gegensatz zu einer Testausführung ohne den interaktiven Modus wird **kein** Abmelden am CRM durchgeführt. Dies muss manuell erfolgen. | | Auswahl ausführen | Führt die markierten Keywords (mehrzeilige Auswahl möglich) aus. Dabei wird das gesamte Keyword ausgeführt, "halbe" Keywords können nicht selektiert werden. | | Breakpoint | Definieren des Breakpoints über eine Zeilennummer. Ein definierter Breakpoint kann über ![Delete.svg](https://help.cursor.de/__attachments/a_be828a6fdbed06743b436120adb4c5d1ef5847546da2b8ad08d472f317dbedd3/Delete.svg?cb=28ecb8af9db8f8ae607608ea534e855b) wieder gelöscht werden. Alternativ wird das Feld geleert. | **Wann wird in den interaktiven Modus gewechselt?** Der interaktive Modus wird immer dann bei der nächsten Testausführung aktiviert, wenn ein Breakpoint definiert wurde, d.h. in dem Eingabefeld eine Zeilennummer eingetragen wurde. Soll die nächste Testausführung wie gehabt von vollständig vom Beginn bis zum Ende ausgeführt werden, muss die Zeilennummer gelöscht werden. ### Wechseln in den interaktiven Modus Wird der Breakpoint erreicht, wechselt das Test-Studio in den interaktiven Modus. ![image2022-11-3_10-2-52.png](https://help.cursor.de/__attachments/a_934020aab2aa69b04a25f4d2376993511ec665e971602c82ec66412e37e9193d/image2022-11-3_10-2-52.png?cb=37e10ee6952100d1551df02411034057) Dabei ändert sich die Oberfläche geringfügig: * Unter dem Testfall werden alle Variablen und ihr letzter Wert eingeblendet. Die Werte können bearbeitet werden. * Im Protokoll wird die Stelle vermerkt, an der in den interaktiven Modus gewechselt wurde. * Alle nachfolgenden Testschritte werden übersprungen -- dies wird entsprechend vermerkt. * Die Schalter "Interaktiven Modus verlassen" und "Auswahl ausführen" werden aktiv. ### Ausführen von Keywords im interaktiven Modus Eine Auswahl an Keywords kann wie folgt ausgeführt werden: * Markieren der Zeilen, die die Keywords umfassen. Dies muss nicht vollständig sein, wie auf dem folgenden Screenshot zu erkennen ist -- in dem Beispiel werden trotzdem die beiden folgenden Keywords ausgeführt. set field "ActTypeKey.Activity" to "ERINNERUNG" save dataset * Auswahl über "Auswahl ausführen" ausführen. * Im Protokoll werden die bekannten Einträge hinterlegt. Dabei ist ersichtlich, dass diese Keywords im interaktiven Modus ausgeführt wurden. Das Protokoll wird erst nach Abschluss aller Keywords aktualisiert, auf dem Screenshot wurde es zusammengefasst, um Platz im Handbuch zu sparen. ![image2022-11-3_10-7-47.png](https://help.cursor.de/__attachments/a_72352338674173370b192e268ad24a25e4210473152922e7b290bbc7a782d930/image2022-11-3_10-7-47.png?cb=fa2cb2e0a2f7d0833f28a032534744f1) ### Ändern von Variablenwerten Bevor eine Auswahl von Keywords ausgeführt wird, können Werte von Variablen in der Tabelle geändert werden. Die geänderten Werte greifen bei allen nachfolgenden Ausführungen von Keywords. Selbstverständlich können auch neue Werte in einem Testfall zugewiesen werden. Die neuen Werte werden hier ebenso angezeigt. ### Erweiterte Autovervollständigung Zur Vervollständigung von [Keywords](https://help.cursor.de/de/tstudio/current/keywords.md) gibt es im interaktiven Modus eine erweiterte [Autovervollständigung](https://help.cursor.de/de/tstudio/current/editorfunktionen-des-test-studios.md). Hierbei werden Vorschläge zur Vervollständigung auf Basis des aktuellen Webclient-Zustands generiert. Dies ermöglicht es Bezeichnungen von Aktionsboxschalter, Buttons, Labels, Tabs und Collapsibles im Editor vorgeschlagen zu bekommen. Beispiel: Auswahl eines Aktionsboxschalters mittels erweiterter Autovervollständigung ![https://jira.cursor.de/secure/attachment/97474/97474_suggestions-actions.png](https://jira.cursor.de/secure/attachment/97474/97474_suggestions-actions.png) Nach der Eingabe des Keywords "start internationalized action" (zum Betätigen des Aktionsboxschalters) wird über STRG + LeER die Autovervollständigung ausgelöst. Es erscheint eine Vorschlagsliste, die alle auf der aktuellen Maske sichtbaren Aktionsboxeinträge aufzeigt. Die passende Aktion kann nun durch Navigation mit den Pfeiltasten und ENTER oder per Maus ausgewählt werden und wird dann in den Code übernommen. ## Generierung von Feldprüfungen anhand der aktuellen Maske Im [interaktiven Modus](https://help.cursor.de/de/tstudio/current/interaktiver-modus.md) steht ab Version 24.3 der Eintrag "Generiere Maskenprüfungen" im Kontextmenü des Editors zur Verfügung (ansonsten ist dieser Eintrag deaktiviert). ![grafik-20240514-111221.png](https://help.cursor.de/__attachments/a_d6411424eafd725c95ed5abe3bdc9626c9bf5ec96285636226be4a0b57ab0b7f/grafik-20240514-111221.png?cb=f56645d72dedc86d6dffe97660aab9ba) Ist die aktuelle Ansicht eine Detailansicht (Entität oder BPM), öffnet sich ein Dialog zur Konfiguration der zu generierenden Feldprüfungen. ![grafik-20240514-111303.png](https://help.cursor.de/__attachments/a_f0843039272c1f336b9fa54024b89422d25ad358e5819f658f11d6cf6e52cdc1/grafik-20240514-111303.png?cb=92eb2ce96e163a3cca77e7929cea00d1) Folgende Konfigurationen sind möglich: * Über "Teilbereiche" kann die Generierung der Prüfungen auf einen Teilbereich der Maske (Tab oder Collapsible) beschränkt werden. * Mittels Checkboxen können die Prüfungen auf einzelne Komponentenarten eingeschränkt werden. Diese Komponenten sind Felder, Texte (Labels ohne Feld-ID), Feldbeschriftungen (Labels mit Feld-ID) und Buttons. * Der Dialog zeigt außerdem eine Vorschau der generierten Feldprüfungen an. * Über den Schalter "Übernehmen" wird der Text aus der Vorschau in den aktuellen Testfall (an der Position an der das Kontextmenü geöffnet worden ist) eingefügt. Details zu den Konfigurationen | Checkbox | Erläuterung | |-----------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Felder | Generierung einer Prüfung für alle sichtbaren Felder auf ihre Sichtbarkeit: * field "Subject.Activity" should be visible | | Aktueller Wert | Generierung einer Prüfung für alle sichtbaren Felder auf ihren aktuellen Feldwert: * field "Subject.Activity" should be "aktueller Wert" | | optional/verpflichtend | Generierung einer Prüfung für alle sichtbaren Felder auf ihren Status der Pflichtfeldeigenschaft: * field "Subject.Activity" should be mandatory (falls das Feld ein unausgefülltes Pflichtfeld ist) * field "Subject.Activity" should be nonmandatory (falls das Feld ein ausgefülltes Pflichtfeld oder gar kein Pflichtfeld ist) | | schreibbar / schreibgeschützt | Generierung einer Prüfung für alle sichtbaren Felder auf ihre Schreibbarkeit: * field "Subject.Activity" should be enabled (falls das Feld schreibbar ist) * field "Subject.Activity" should be disabled (falls das Feld schreibgeschützt ist) | | Ausblendungen prüfen | Generierung einer Prüfung für jedes nicht sichtbare Feld: * field "Subject.Activity" should be invisible | | Texte (Labels ohne Feld-ID) | Generierung einer Prüfung für alle sichtbaren Texte auf ihre Sichtbarkeit: * label "labelId" should be visible | | Aktueller Text | Generierung einer Prüfung für alle sichtbaren Texte auf ihren aktuellen Text: * label "labelId" should be "aktueller Text" | | Ausblendungen prüfen | Generierung einer Prüfung für jeden nicht sichtbaren Text: * label "labelId" should be invisible | | Feldbeschriftungen (Labels mit Feld-ID) | Generierung einer Prüfung für alle sichtbaren Feldbeschriftungen auf ihre Sichtbarkeit: * label "Subject.Activity" should be visible | | Aktuelle Beschriftung | Generierung einer Prüfung für alle sichtbaren Feldbeschriftungen auf ihre aktuelle Beschriftung: * label "Subject.Activity" should be "aktuelle Beschriftung" | | Ausblendungen prüfen | Generierung einer Prüfung für jede nicht sichtbare Feldbeschriftung * label "Subject.Activity" should be invisible | | Buttons | Generierung einer Prüfung für alle sichtbaren Buttons auf ihre Sichtbarkeit: * button "scriptButtonId" should be visible | | Aktuelle Beschriftung | Generierung einer Prüfung für alle sichtbaren Buttons auf ihre aktuelle Beschriftung: * button "scriptButtonId" should be "aktuelle Beschriftung" | | aktiviert / deaktiviert | Generierung einer Prüfung für alle sichtbaren Buttons auf ihren Status: * button "scriptButtonId" should be enabled (falls der Button aktiviert ist) * button "scriptButtonId" should be disabled (falls der Button deaktiviert ist) | | Ausblendungen prüfen | Generierung einer Prüfung für jeden nicht sichtbaren Button: * button "scriptButtonId" should be invisible | ## Tastenkürzel Um die Testentwicklung weiter zu beschleunigen, sind alle Funktionen des interaktiven Modus mit der Tastatur erreichbar. ### Hauptnavigation | **Tastenkombination** | **Aktion** | |-----------------------|---------------------------------------------------| | STRG + UMSCHALT ⇧ + 1 | Wechsel in den Testfalleditor. | | STRG + UMSCHALT ⇧ + 2 | Wechsel in die Variablentabelle, sofern sichtbar. | | STRG + UMSCHALT ⇧ + 3 | Wechsel in das Protokoll. | | STRG + UMSCHALT ⇧ + 4 | Wechsel in das detaillierte Protokoll. | ### Aktionen rund um den interaktiven Modus | **Tastenkombination** | **Aktion** | |-----------------------|-------------------------------------------------| | STRG + B | Wechselt in das Eingabefeld für den Breakpoint. | | STRG + UMSCHALT ⇧ + B | Entfernt einen vorher gesetzten Breakpoint. | | STRG + R | Führt die ausgewählten Keywords aus. | | STRG + Q | Beendet den interaktiven Modus. | ### Aktionen in der Variablentabelle | **Tastenkombination** | **Aktion** | |-----------------------|------------------------------------------------------| | F2 | Bearbeitet den Variablenwert der ausgewählten Zeile. | --- version: "current" language: "de" --- # Keywords ## Allgemein *** ** * ** *** ### create dataset **Parameter** *Keine* **Aktion** Startet die Neuanlage eines Datensatzes der geöffneten Entität **Beispiel** Groovy create dataset *** ** * ** *** ### create dependent dataset **Parameter** *Keine* **Aktion** Startet die Neuanlage eines abhängigen Datensatzes (d.h. über den Unterbereich) auf der aktuell geöffneten Relation (der aktive Tab im Unterbereich). **Beispiel** Groovy create dependent dataset *** ** * ** *** ### open *parameter* dataset **Parameter** *1st\|2nd\|3rd\|10th* **Aktion** Öffnet den *i* -ten Datensatz oder den ersten, der *alle* angegebenen Suchkriterien erfüllt, aus der gerade sichtbaren Tabelle (Suchergebnis- oder Unterbereichstabelle). **Beispiel** Groovy open 1st dataset open 2nd dataset open 3rd dataset open 10th dataset from subdata open dataset from subdata matching { field "ActTypeKey.Activity" matches ~/.*/ // regex pattern field "Subject.Activity" equals "Mein Betreff" } open dataset matching { ... } *** ** * ** *** ### open entity "entityName" **Parameter** *entityName* technischer Name der Entität **Aktion** Öffnet über das Bereich-/Dateimenü eine leere Maske der übergebenen Entität. Je nach Konfiguration des Systems wird die Einfeldsuche oder die Suchmaske geöffnet. Kann die Entität über das Bereich-/Dateimenü nicht geöffnet werden, wird sie über die COMMAND-Suche geöffnet. Voraussetzung dafür ist, dass die Entität auch für die COMMAND-Suche freigegeben ist. Die "Bereiche" in der Seitenleiste müssen für dieses Keyword geöffnet sein. Sollten sie zusammengeklappt sein, schlägt das Keyword fehl. Um die "Bereiche" dauerhaft aus zuklappen, muss sich mit dem Test-Benutzer am CRM angemeldet werden und das Ausklappen einmal händisch durchgeführt werden. Beim Abmelden wird die Änderung gespeichert. * ![image-20240125-100443.png](https://help.cursor.de/__attachments/a_be6b2a147125de76d4d7588fef1036cd499da50573199bdfdbaf549af6649e14/image-20240125-100443.png?cb=f9331b4d683abb72620873664c651b69) **Beispiel** Groovy open entity "Customer" *** ** * ** *** ### open searchmask **Parameter** *Keine* **Aktion** Öffnet die Suchmaske ("Erweiterte Suche") einer Entität. Dies funktioniert *nicht* aus der Detailmaske heraus. **Beispiel** Groovy open searchmask *** ** * ** *** ### open listview **Parameter** *Keine* **Aktion** Öffnet die Listenansicht einer Entität. Dies funktioniert nur aus einer Detailmaske heraus. **Beispiel** Groovy open listview *** ** * ** *** ### open subdata listview **Parameter** *Keine* **Aktion** Öffnet die Listenansicht der im Unterbereich zugeordneten Entitäten. Dies funktioniert nur aus einer Detailmaske heraus. **Beispiel** Groovy open subdata listview *** ** * ** *** ### open tasklist **Parameter** *Keine* **Aktion** Öffnet die Liste der offenen Tasks für den aktuellen Benutzer. Ist die Taskliste bereits geöffnet, wird sie geschlossen und erneut geöffnet. **Beispiel** Groovy open tasklist *** ** * ** *** ### prompt tester interaction *steps* **Parameter** *steps* Liste von Strings, die beschreiben, welche Schritte der Anwender vornehmen muss, um den Testlauf fortzusetzen. **Aktion** Pausiert den Testlauf für manuelle Eingaben des Anwenders, falls die zu testenden Funktionen noch nicht über das Test Studio abgedeckt werden. Es wird eine Meldung angezeigt, die dem Anwender die notwendigen Schritte erläutert. Bestätigt der Anwender die Meldung, wird der Testlauf fortgesetzt. Steht nicht in der automatischen Ausführung (Headless-mode) zur Verfügung. Falls es dennoch genutzt wird, bricht der Test an dieser Stelle ab. **Beispiel** Groovy prompt tester interaction "Wählen Sie den ersten Datensatz im Unterbereich aus", "Entfernen Sie ihn aus dem Unterbereich", "Setzen Sie den Testlauf fort" *** ** * ** *** ### reload dataset **Parameter** *Keine* **Aktion** Lädt den aktuellen Datensatz erneut. **Beispiel** Groovy reload dataset *** ** * ** *** ### save dataset **Parameter** *Keine* **Aktion** Speichert den geöffneten Datensatz. **Beispiel** Groovy save dataset *** ** * ** *** ### delete dataset **Parameter** *Keine* **Aktion** Löscht den geöffneten Datensatz. **Beispiel** Groovy delete dataset *** ** * ** *** ### deselect all rows **Parameter** *Keine* **Aktion** Deselektiert alle Zeilen einer Tabelle. **Beispiel** Groovy deselect all rows *** ** * ** *** ### select *parameter* **Parameter** *1st row \| rows matching {...} \| all rows* **Aktion** Markiert additiv einen (mehrere) Datensatz (Datensätze) in einer Tabelle. Die ausgewählten Enträge werden also zu den bereits selektierten Datensätzen hinzugefügt. Erfolgt entweder auf Index-Basis oder nach Suchkriterien. Es werden *alle* Zeilen markiert, die die Bedingungen erfüllen. Für die Auswahl eines Datensatzes. **Tipp** * Falls sichergestellt sein soll, dass nur die ausgewählten Zeilen selektiert sind, sollte vorher die Aktion *'deselect all rows'* genutzt werden. * Zum Markieren aller Meiers und Mustermanns wird das Keyword zweimal aufgerufen. Groovy deselect all rows select rows matching { field "Name1.Customer" equals "Meier" } select rows matching { field "Name1.Customer" equals "Mustermann" } **Beispiel** Groovy select 1st row select 2nd row select 3rd row select 4th row select rows matching { field "Name.Entity" equals "someString" field "Name.Entity" == "someString" // Alternative zur vorigen Zeile. field "Name.Entity" matches ~/.*AB/ // java.util.regex.Pattern } select all rows // alle Zeilen, Paginator-übergreifend *** ** * ** *** ### select tab "tabName" **Parameter** *tabName* Dargestellter Name des gewünschten Tabs auf der Maske. Ab einer CRM-Version von 23.2 kann zusätzlich der technische Name verwendet werden. **Aktion** Wechselt zum Tab auf der Maske mit dem übergebenen Namen bzw. Beschriftung. Falls der Name nicht eindeutig ist, wird der zuerst gefundene Tab verwendet. Das Auswählen findet im Falle einer übergebenen Beschriftung ohne Beachtung der Groß- und Kleinschreibung statt. Bei Verwendung des technischen Namens, muss dieser jedoch genau übereinstimmen. **Beispiel** Groovy select tab "DETAILS" select tab "CampaignTab" *** ** * ** *** ### toggle collapsible "collapsibleName" **Parameter** *collapsibleName* Interner Name des gewünschten Collapsibles auf der Maske **Aktion** Wechselt den Status des über den übergebenen internen (technischen) Namen identifizierten Collapsibles. Ein ausgeklapptest Collapsible wird hiermit eingeklappt, ein eingeklapptes Collapsible ausgeklappt. Das Keyword ist insbesondere dann notwendig, wenn Collapsible-Elemente standardmäßig eingeklappt sind, da das Test-Studio genau wie ein menschlicher Benutzer nicht auf "weggeklappte" Elemente zugreifen kann. **Beispiel** Groovy toggle collapsible "C0InvolvedPersonsCollapsible" **Abbildung** ![image2022-8-1_10-43-31.png](https://help.cursor.de/__attachments/a_2920ae3b348b590953a98775de2906a2059ef3c594c6bc8f167f4febd2c7f4c9/image2022-8-1_10-43-31.png?cb=5cbef3e527613f993311c0b7ba1cf257) *** ** * ** *** ### enter edit mode **Parameter** *Keine* **Aktion** Wechselt den aktuellen Datensatz in den Bearbeitungsmodus. **Beispiel** Groovy enter edit mode *** ** * ** *** ### enter read mode **Parameter** *Keine* **Aktion** Wechselt den aktuellen Datensatz in den Lesemodus. **Beispiel** Groovy enter read mode *** ** * ** *** ### execute "*libraryMethodName"* **Parameter** *libraryMethodName*Name der auszuführenden Bibliotheksmethode. Dieser setzt sich zusammen aus dem Namen der Bibliothek und der gewünschten Bibliotheksmethode. **Aktion** Führt eine Bibliotheksmethode, welche keine weiteren Parameter benötigt, aus. **Beispiel** Groovy execute "AssignmentLib.removeAllDatasets" ### execute "*libraryMethodName"* using { *parameter* } **Parameter** *libraryMethodName*Name der auszuführenden Bibliotheksmethode. Dieser setzt sich zusammen aus dem Namen der Bibliothek und der gewünschten Bibliotheksmethode. *parameter*Parameter, die in der ausgewählten Methode definiert sind. **Aktion** Führt eine Bibliotheksmethode unter Verwendung der dazugehörigen Parametern aus. **Beispiel** execute "BPMUtils.startProcess" using { parameter processName : "Mein Prozess" parameter occasion: "Mein Anlass" // ggf. weitere Parameter } ## Befüllen *** ** * ** *** ### fill mask using *values* **Parameter** *values* Liste von Feldwerte, die gesetzt werden sollen **Aktion** Füllt die aktuelle Maske mit den übergebenen Feldwerten. **Beispiel** Groovy fill mask using { lookup "PersontypeKey.Customer": "H" textfield "Name1.Customer": "Mustermann" datefield "DateOfOrigin.Customer": "01.01.1970" } *** ** * ** *** ### set lookupfield "fieldname" through searching using *searchParameter* **Parameter** *fieldname* Name des zu füllenden Nachschlagefeldes *searchParameter* Felder auf der Suchmaske, die gefüllt werden sollen **Aktion** Das angegebene Nachschlagefeld wird durch die dahinter liegende Nachschlagesuche gefüllt. Dabei wird immer der erste ermittelte Datensatz in das Feld eingetragen. Innerhalb von *searchParameter* können mehrere Felder gefüllt werden. **Beispiel** Groovy set lookupfield "DefaultContactPerson.Activity" through searching using { field "LastName.ContactPerson": "Mustermann" field "FirstName.ContactPerson": "Max" } *** ** * ** *** ### set field "fieldName" to "value" **Parameter** *fieldname* Name des zu setzenden Textfeldes *value* gewünschter Wert **Aktion** Setzt das angegebene Feld (Text, Zahl) auf einen gewünschten Wert. Die Maske sollte sich dafür bereits im Bearbeitungsmodus befinden. **Beispiel** Groovy set field "Subject.Activity" to "Mein Betreff" set field "Subject.Activity" to "12345" **Tipp** Auch Nachschlagefelder können mit diesem Keyword gefüllt werden. Der notwendige Lucene-Index könnte allerdings nicht so schnell gesetzt worden sein. Um spätere Fehlermeldung zu vermeiden, empfiehlt sich, direkt nach der Eingabe des Feld eine Feldprüfung vorzunehmen. Weitere Informationen siehe [Bekannte Einschränkungen](https://help.cursor.de/de/tstudio/current/bekannte-einschrankungen.md) Groovy set field "Subject.Activity" to "Mein Betreff" field "Subject.Activity" should be "Mein Betreff" set field "Subject.Activity" to "12345" field "Subject.Activity" should be "12345" *** ** * ** *** ### clear *fieldType "fieldName"* **Parameter** *fieldname* Name des zu setzenden Textfeldes *fieldType*datefield\|textfield\|lookup\|textarea\|htmlarea\|booleanfield oder field **Aktion** Leert bzw. deselektiert das angegebene Feld. **Beispiel** Groovy clear field "EndDate.Activity" // das Test-Studio ermittelt selbst, um was für einen Feldtyp es sich handelt clear datefield "EndDate.Activity" clear textfield "Subject.Activity" clear lookupfield "PersontypeKey.Customer" *** ** * ** *** ## BPM *** ** * ** *** ### assign process to me **Parameter** *Keine* **Aktion** Weist den geöffneten Prozesstask dem aktuellen Benutzer über den "Mir zuweisen"-Button zu. **Beispiel** Groovy assign process to me *** ** * ** *** ### cancel process **Parameter** *Keine* **Aktion** Bricht den aktuellen Prozess ab, indem auf den Abbrechen-Button geklickt und die darauf folgende Meldung bestätigt wird. **Beispiel** Groovy cancel process *** ** * ** *** ### fill bpm selection mask using *searchParameter* **Parameter** *searchParameter* Feldwerte für die Suchmaske **Aktion** Füllt die Eingabefelder einer Suchmaske mit den übergebenen Werten. Die Suche muss mit dem Keyword [execute-search](https://help.cursor.de/de/tstudio/current/keywords.md#execute-search) ausgeführt werden. **Beispiel** Groovy fill bpm selection mask using { lookup "PersontypeKey.Customer": "H" textfield "Name1.Customer": "Mustermann" } *** ** * ** *** ### Fortsetzen eines gestarteten BPM-Prozesses Eine BPM-Prozessaktion kann in der Taskliste auf zwei Arten gefunden werden: * Über den Namen des Tasks (im Screenshot rot markiert) * Über die Beschreibung ("Instanzinfo") der Prozessaktion (im Screenshot blau markiert) Die entsprechenden Keywords sind nachfolgend ausgeführt. ![image2019-10-25_12-43-47.png](https://help.cursor.de/__attachments/a_03b49c389390507702661921a7231a36dff44254c17ae417215478e40a6b62f4/image2019-10-25_12-43-47.png?cb=fa36d2386471b1da755a9b3fa51979ac) *** ** * ** *** ### open bpm task "taskname" **Parameter** *taskname* Name des zu öffnenden Tasks **Aktion** Öffnet einen Prozess aus der Taskliste, wenn diese bereits geöffnet ist. **Beispiel** Groovy open bpm task "Kampagnenphase und Outbound hinzufügen" open bpm task "Kampagne anlegen" *** ** * ** *** ### open bpm instance "instanceDescription" **Parameter** *instanceDescription* Beschreibung des zu öffnenden Tasks **Aktion** Öffnet einen Task aus der Taskliste, wenn diese bereits geöffnet ist. **Beispiel** Groovy open bpm instance "Anlage der Kampagne [Das CURSOR-Test-Studio]" open bpm instance "Kampagnendaten pflegen" *** ** * ** *** ### start internationalized process "processName" **Parameter** *Keine* *processName*internationalisierter Name des zu startenden Prozesses **Aktion** Startet einen Prozess aus dem Prozessmenü anhand des sichtbaren internationalisierten Prozessnamens. Das Menü "Prozesse" in der Seitenleiste müssen für dieses Keyword sichtbar und geöffnet sein. Sollte es nicht sichtbar oder zusammengeklappt sein, schlägt das Keyword fehl. Um das Menü "Prozesse" dauerhaft auszuklappen, muss sich mit dem Test-Benutzer am CRM angemeldet werden, das Menu eingeblendet werden und das Ausklappen einmal händisch durchgeführt werden. Beim Abmelden wird die Änderung gespeichert. * ![image-20240125-101009.png](https://help.cursor.de/__attachments/a_366b874d9f8cdba9ec49ce01d33edd027150ac0a47b9d7c51cd6689cb54f54c8/image-20240125-101009.png?cb=3797fb15b5c78345980be8ebde9e3277) * ![image-20240125-101032.png](https://help.cursor.de/__attachments/a_23059b0bab83c474750fe43c1ac34c2f646bc228d39097ef5fc8dabd346445c8/image-20240125-101032.png?cb=c9884d83c905d97bd568c68909ca35ee) **Beispiel** Groovy start internationalized process "Kampagne anlegen" *** ** * ** *** ### current bpm phase should be \ Die Phasen werden teils abgeschnitten und wie hier mit "..." dargestellt dargestellt. In Diesem Fall ist statt des Originalnamens der Phase "..." zu verwenden, also: current bpm phase should be "..." \>\> "Phase3" \>\> "Phase4" \>\> "..." \>\> "Teilphase4" \>\> "Teilphase5" ![bpmPhasen.PNG](https://help.cursor.de/__attachments/a_c6d7a8b3afeef2226f1e5c4f4948d0090b9b24f2424f00fd85dfa13723df9cf7/bpmPhasen.PNG?cb=673b844a3cc8c0099b5f34900d4adede) **Parameter** *\ dargestellter Name der Phasen bis zu der zu prüfenden Phase.* **Aktion** Überprüft ob der angegeben Pfad übereinstimmt und ob die zuletzt angegebene Phase aktiv ist. **Beispiel** Groovy current bpm phase should be "Phase1" >> "Phase2" >> "Phase3" *** ** * ** *** ### borrow document and restore \>=24.3 **Parameter** *Keine* **Aktion** Überspringt das Herunterladen und Speichern eines Dokuments in einem BPM-Usertask **Beispiel** 1 borrow document and restore Damit das Keyword korrekt funktioniert, muss die erweiterte Dateibehandlung für den ausführenden User **deaktiviert** sein. ### upload document "filename" \>=26.6 **Parameter** *filename* Der Dateiname des hochzuladenden Dokuments **Aktion** Lädt ein leeres Dokument mit dem angegeben Pfad hoch. Das Keyword kann für Benutzertasks vom Typ "Dokument hochladen" und für die Dokumentenneuanlage verwendet werden. **Beispiel** upload document "MyPdf.pdf" upload document "MyExcel.xlsx" *** ** * ** *** ## Interaktion *** ** * ** *** ### click button *"buttonID* " **Parameter** *buttonID*internen Name des Buttons **Aktion** Klickt auf den Button mit dem übergebenen technischen Namen. Die gewünschten Buttons müssen sich auf der Maske befinden. Toolbar-Buttons können mit dieser Variante nicht betätigt werden **Beispiel** Groovy click button "btn_medium_strom" *** ** * ** *** ### click action *"actionID* " \>=24.4 **Parameter** *actionID*interner Name des Aktionsboxschalters **Aktion** Klickt auf den Aktionsboxschalter mit dem übergebenen internen Namen. Die Aktionsbox muss dafür bereits aufgeklappt sein. **Beispiel** Groovy click action "C0createCommon" ### click myCrm path **Parameter** *path* Pfad zum gewünschten Element **Aktion** Klickt das Element im gewünschten Pfad. **Beispiel** Groovy click myCrm >> "Mein Ordner" >> "Noch ein Ordner" >> "Mein Prozess" click myEvi >> "Mein Ordner" >> "Noch ein Ordner" >> "Mein Prozess" click myTina >> "Mein Ordner" >> "Noch ein Ordner" >> "Mein Prozess" *** ** * ** *** ### confirm task **Parameter** *Keine* **Aktion** Setzt den aktuellen Prozess fort, indem auf den Fortsetzen-Button geklickt wird. **Beispiel** Groovy confirm task *** ** * ** *** ### execute search **Parameter** *Keine* **Aktion** Führt die Suche der aktuellen Suchmaske aus. **Beispiel** Groovy execute search *** ** * ** *** ### pick internationalized task option "*buttonCaption* " **Parameter** *buttonCaption* Inhalt eines Buttons als String **Aktion** Drückt einen Button einer Meldung Bei User-Task vom Typ "Dialog" : pick dialog option "*ButtonCaption*" **Beispiel** Groovy pick internationalized task option "zweiter Schalter" *** ** * ** *** ### pick task option *option* **Parameter** *option* Button-Option: OK, YES, NO oder Integer: 0,1,2,... oder String: "firstButton", "secondButton",... **Aktion** Drückt einen Button einer Meldung eines BPM-Prozesses **Beispiel** Groovy pick task option OK pick task option 0 // der erste Button ist der 0te pick task option 1 pick task option YES pick task option "firstButton" *** ** * ** *** ### pick dialog option *option* **Parameter** *option* Button-Option: OK, YES, NO oder Integer: 0,1,2,... oder String: "firstButton", "secondButton",... **Aktion** Drückt einen Button einer Meldung **Beispiel** Groovy pick dialog option YES pick dialog option NO pick dialog option OK pick dialog option CANCEL pick internationalized dialog option "firstButton" *** ** * ** *** ### suspend task (and save\|discard) **Parameter** *Keine* **Aktion** Pausiert den aktuellen Prozess, indem auf den Pausieren-Button geklickt wird. **Beispiel** Groovy suspend task suspend task and save suspend task and discard **Tipp** War der aktuelle Prozess-Schritt eine Maske, auf der Feldwerte geändert wurden, so erscheint ein Dialog, ob diese Werte zwischengespeichert werden sollen. Dieser muss durch den Zusatz `and save` respektive `and discard` behandelt werden. Wurden keine Werte geändert, erscheint der Dialog nicht. *** ** * ** *** ### start internationalized action "*actionName* " **Parameter** *actionName* Beschriftung des Buttons in der Aktionsbox **Aktion** Startet eine Aktion mit dem übergebenen Namen aus der Aktionsbox. **Beispiel** Groovy start internationalized action "Kampagne anlegen" *** ** * ** *** ### copy dataset Kopiert den Datensatz ohne Dokumentenzuordnung und verknüpft diesen mit dem Original. *** ** * ** *** ### copy activities with copies Kopiert sowohl die Aktivität als auch zugeordnete Dokumente. Verknüpft anschließend die Kopien der Dokumente und die ursprüngliche Aktivität mit dem neuen Datensatz. *** ** * ** *** ### copy activity with documents Kopiert die Aktivität mit den bestehenden Dokumentenzuordnungen und verknüpft die Kopie mit dem Original. *** ** * ** *** ### copy activity without documents Kopiert die Aktivität ohne Dokumentenzuordnung und verknüpft die Kopie mit dem Original. *** ** * ** *** ## Überprüfen ### subdata size should be *parameter* **Parameter** *parameter* Anzahl der verknüpften Datensätze **Aktion** Prüft, ob die aktuelle Anzahl der verknüpften Datensätze im aktuell geöffnetem Unterbereich der im Parameter definierten Anzahl entspricht. **Beispiel** subdata size should be "0" subdata size should be "125" *** ** * ** *** ### liste size should be *parameter* **Parameter** *parameter* Anzahl der verknüpften Datensätze **Aktion** Prüft, ob die aktuelle Anzahl der verknüpften Datensätze in der ausgewählten Liste der im Parameter definierten Anzahl entspricht. **Beispiel** list size should be "1" list size should be "25" *** ** * ** *** ### current view should be *parameter* **Parameter** *parameter* listview \| detailmask \| bpm user task \| searchmask \| mail \| desktop **Aktion** Prüft, ob die aktuelle Ebene ein(e) Listenansicht\|Detailmaske\|BPM-Usermaske\|Suchmaske\|E-Mail\|der CRM-Desktop ist. Über die zweite Variante "belong to" ist es möglich, zu prüfen, ob die Ebene zur gewünschten Entität gehört. **Beispiel** Groovy open entity "Activity" current view should be detailmask|searchmask|bpm user task|listview|desktop current view should belong to "Activity" // aktuelle Ebene gehört zu Entität "Activity" *** ** * ** *** ### current view should belong to *EntityName* **Parameter** *EntityName*technischer Name der zu prüfenden Entität **Aktion** Prüft, ob die aktuell geöffnete Maske zu einer definierten Entität gehört. **Beispiel** Groovy open entity "Activity" current view should belong to "Activity" // aktuelle Ebene gehört zu Entität "Activity" Die zugehörige Entität von Suchmaske/Listenansicht kann mit dem Keyword "current view belongs to *EntityName*" nicht überprüft werden. *** ** * ** *** ### field "fieldName" should be *value* Dies ist die allgemeine Variante des Keywords, da der genaue Feldtyp nicht angegeben werden muss, sondern von Test-Studio selbstständig ermittelt wird. **Parameter** *fieldName* Name des zu prüfenden Datumsfeldes *value* gewünschter Wert **Aktion** Prüft das angegebene Datumsfeld auf einen gewünschten Wert. Folgende Werte können verwendet werden: * "Wert": Tatsächlicher Wert des Feldes * `enabled / disabled`: Schreibbar / gesperrt * `visible / invisible`: Sichtbar / ausgeblendet auf der Maske * `mandatory / nonmandatory`: Pflichtfeld / kein Pflichtfeld * `blank / filled`: Feld vollständig geleert (bei Nachschlagefeldern bedeutet dies, dass nicht einmal der Leerschlüssel eIngetragen ist) / irgendein Wert steht drin (das schließt den Leerschlüssel mit ein) * `emptykey / anything`: Der Leerschlüssel ist eingetragen / irgendein Wert, der nicht der Leerstring oder der Leerschlüssel ist, steht in dem Feld . ![warning](https://help.cursor.de/__attachments/a_8115f0b735e1176679ea066c60adf519b379e6fdc23d1b639e85b0b3a68ffb68/atlassian-warning?cb=14432459925d605e05cae2605cdfe666) Steht nur bei Nachschlagefeldern zur Verfügung. Erzeugt auf anderen Feldern eine Fehlermeldung. *** ** * ** *** ### field "fieldName" should contain *value* \>=25.3 **Parameter** *fieldName* Name des zu prüfenden Datumsfeldes *value* gewünschter Wert **Aktion** Prüft ein textbasiertes Feld, ob der definierte Text enthalten ist. **Beispiel** Groovy field "CustomerPk.Installation" should contain "CURSOR1732681852338" field "CustomerPk.Installation" should match pattern ~/.*AB/ // regex pattern Die Keywords stehen nicht für Datums- und Booleanfelder zur Verfügung. *** ** * ** *** ### datefield "fieldName" should be *value* **Parameter** *fieldName* Name des zu prüfenden Datumsfeldes *value* gewünschter Wert **Aktion** Prüft das angegebene Datumsfeld auf einen gewünschten Wert. Folgende Werte können verwendet werden: * "Wert": Tatsächlicher Wert des Datumsfeldes * `enabled / disabled`: Schreibbar / gesperrt * `visible / invisible`: Sichtbar / ausgeblendet auf der Maske * `mandatory / nonmandatory`: Pflichtfeld / kein Pflichtfeld * `blank / filled`: Feld vollständig geleert (bei Nachschlagefeldern bedeutet dies, dass nicht einmal der Leerschlüssel eIngetragen ist) / irgendein Wert steht drin (das schließt den Leerschlüssel mit ein) Ist nicht der gewünschte Wert eingetragen bzw. das Feld im gewünschten Status, wird dies als Fehler gewertet. **Beispiel** Groovy datefield "BeginDate.Activity" should be enabled // schreibbar datefield "EndDate.Activity" should be "24.12.2018" // 24.12.2018 als Datum im Feld eingetragen datefield "EndDate.Activity" should be "24.12.2018 12:00" // 24.12.2018 12:00 als Datum mit Uhrzeit im Feld eingetragen datefield "Begin.Activity" should be mandatory // Pflichtfeld *** ** * ** *** ### lookupfield "fieldName" should be value **Parameter** *fieldName* Name des zu prüfenden Nachschlagefeldes *value* gewünschter Wert/Eigenschaft **Aktion** Prüft das angegebene Nachschlagefeld auf einen gewünschten Wert. Folgende Werte können verwendet werden: * "Wert": Tatsächlicher Wert des Feldes * `enabled / disabled`: Schreibbar / gesperrt * `visible / invisible`: Sichtbar / ausgeblendet auf der Maske * `mandatory / nonmandatory`: Pflichtfeld / kein Pflichtfeld * `blank / filled`: Feld vollständig geleert (bei Nachschlagefeldern bedeutet dies, dass nicht einmal der Leerschlüssel eIngetragen ist) / irgendein Wert steht drin (das schließt den Leerschlüssel mit ein) * `emptykey / anything`: Der Leerschlüssel ist eingetragen / irgendein Wert, der nicht der Leerstring oder der Leerschlüssel ist, steht in dem Feld . Ist nicht der gewünschte Wert eingetragen bzw. das Feld im gewünschten Status, wird dies als Fehler gewertet. **Beispiel** Groovy lookupfield "DefaultContactPerson.Activity" should be enabled // schreibbar lookupfield "DefaultContactPerson.Activity" should be "MUSTERMANN" // MUSTERMANN als Schlüssel im Feld eingetragen lookupfield "DefaultContactPerson.Activity" should be mandatory // Pflichtfeld *** ** * ** *** ### textfield "fieldName" should be*value* **Parameter** *fieldName* Name des zu prüfenden Feldes *value* gewünschter Wert **Aktion** Prüft das angegebene Feld (Text, Zahl, Boolean) auf einen gewünschten Wert. Folgende Werte können verwendet werden: * "Wert": Tatsächlicher Wert des Feldes * `enabled / disabled`: Schreibbar / gesperrt * `visible / invisible`: Sichtbar / ausgeblendet auf der Maske * `mandatory / nonmandatory`: Pflichtfeld / kein Pflichtfeld * `blank / filled`: Feld vollständig geleert (bei Nachschlagefeldern bedeutet dies, dass nicht einmal der Leerschlüssel eIngetragen ist) / irgendein Wert steht drin (das schließt den Leerschlüssel mit ein) Ist nicht der gewünschte Wert eingetragen bzw. das Feld im gewünschten Status, wird dies als Fehler gewertet. **Beispiel** Groovy textfield "Subject.Activity" should be enabled // schreibbar textfield "Subject.Activity" should be "Betreffzeile" // Betreffzeile als Text im Feld eingetragen textfield "Subject.Activity" should be mandatory // Pflichtfeld *** ** * ** *** ### label "theLabel" should be *value* **Parameter** *theLabel* interner Name des Labels (Eigenschaft Name im GUI Builder) *value* gewünschter Wert **Aktion** Prüft das angebene Label auf einen gewünschten Wert. Folgende Werte können verwendet werden: * *"someValue"*: Angezeigter Text * `visible / invisible`: Sichtbar / ausgeblendet auf der Maske **Beispiel** Groovy label "customerSatisfaction" should be "Happy" label "customerSatisfaction" should be visible label "customerSatisfaction" should be invisible *** ** * ** *** ### button "buttonID" should be *value* \>=24.4 **Parameter** *buttonID* interner Name des zu prüfenden Buttons *value* gewünschter Wert **Aktion** Prüft den angegebenen Button auf einen gewünschten Wert. Folgende Werte können verwendet werden: * *"Wert"*: Tatsächlicher Wert des Feldes * `enabled / disabled`: Aktiviert (Kann ich den Button anklicken?) / deaktiviert * `visible / invisible`: Sichtbar / ausgeblendet auf der Maske **Beispiel** Groovy button "buttonID" should be enabled button "buttonID" should be disabled button "buttonID" should be visible button "buttonID" should be invisible button "buttonID" should be "Click me!" *** ** * ** *** ### collapsible "collapsibleID" should be *value* \>=25.3 **Parameter** *collapsibleID* interner Name des zu prüfenden Collapsibles *value* gewünschter Wert **Aktion** Prüft das angegebene Collapsible auf einen gewünschten Wert. Folgende Werte können verwendet werden: * `visible / invisible`: Sichtbar / ausgeblendet auf der Maske * `collapsed / expanded`: Eingeklappt / ausgeklappt **Beispiel** Groovy collapsible "collapsibleGroup100" should be visible collapsible "collapsibleGroup100" should be expanded *** ** * ** *** ### action "actionID" should be *value* \>=24.4 **Parameter** *actionID* interner Name des zu prüfenden Aktionsboxschalters *value* gewünschter Wert **Aktion** Prüft den angebenen Aktionsboxschalter auf einen gewünschten Wert. Folgende Werte können verwendet werden: * *"Wert"*: Tatsächlicher Wert des Feldes * `enabled / disabled`: Aktiviert (Kann ich den Button anklicken?) / deaktiviert * `visible / invisible`: In der Aktionsbox sichtbar / nicht sichtbar **Beispiel** Groovy action "actionID" should be enabled action "actionID" should be disabled action "actionID" should be visible action "actionID" should be invisible action "actionID" should be "Click me!" *** ** * ** *** ### advanced right template should contain { group "groupName" permitted values } **Parameter** *groupName* der zu prüfenden Gruppe *values* read, write, confidential, edit **Aktion** Prüft für jede angegebene Gruppe die Rechte auf dem derzeitigen Datensatz: * *"Werte"*: Liste aller Rechte welche die jeweilige Gruppe besitzt. Alle nicht angegebenen Rechte werden auf fehlendes Recht geprüft. * `read`: Die Gruppe besitzt Leserecht * `write`: Die Gruppe besitzt Schreibrecht * confidential: Die Gruppe besitzt das Recht für vertrauliche Felder * edit: Die Gruppe darf Rechte auf dem Datensatz ändern **Beispiel** Groovy advanced right template should contain { group "ADMINISTRATION" permitted read, write, confidential, edit group "default" permitted read, write, edit group "GUEST" permitted read, write group "USERS" permitted read, write } *** ** * ** *** ### advanced right template should not contain groups values **Parameter** *values* Name aller Gruppen, welche der Datensatz nicht enthalten soll. **Aktion** Prüft für jede angegebene Gruppe ob diese im Rechtedialog eines Datensatzes unter den Tab 'Erweitert' gefunden werden kann. **Beispiel** Groovy advanced right template should not contain groups "DOESNOTEXIST", DOESNOTEXISTASWELL" *** ** * ** *** ### current view should be mail \>=24.3 **Beispiel** current view should be mail ## Navigation *** ** * ** *** ### go back **Parameter** *Keine* **Aktion** Geht in der CRM-History einen Eintrag zurück. Mit dieser Aktion ist es zum Beispiel möglich aus einer im Unterbereich geöffneten Entität wieder zurück auf die ursprüngliche Entität zu springen. Die Funktionalität entspricht der des rot markierten Buttons, siehe Screenshot. ![GoBackDocuKeywords.png](https://help.cursor.de/__attachments/a_61e07e6f5e8383a8dbfb37cc4229469f43a06b1ecde19d87178d0775cf10a0a5/GoBackDocuKeywords.png?cb=b8de0ba3d82d639fab0e231795a6f537) **Beispiel** Groovy go back *** ** * ** *** ### close level (and save\|discard) **Parameter** *Keine* **Aktion** Schließt die aktuelle Ebene. Falls diese ein geänderter Datensatz ist, besteht die Möglichkeit die Änderungen mit save zu speichern oder mit discard zu verwerfen. **Beispiel** Groovy close level close level and save close level and discard Der Zusatz "and save/discard" ist nicht zum Schließen von Maildialogen geeignet. Hierfür ist die Kombination [close level](https://help.cursor.de/de/tstudio/current/keywords.md#close-level-(and-save%257Cdiscard)) + [pick task option YES](https://help.cursor.de/de/tstudio/current/keywords.md#pick-task-option-option) zu verwenden. *** ** * ** *** ### open subdata entity "entityName" **Parameter** *entityName*Name der Entität **Aktion** Öffnet eine Entität aus dem Unterbereich. **Beispiel** Groovy open subdata entity "Activity" open subdata entity "Activity" using "rCoPeAc|interner Relationsname" *** ** * ** *** ### open subdata searchmask **Parameter** *Keine* **Aktion** Öffnet die Suche für die verknüpften Datensätze der im Unterbereich ausgewählten Entität. **Beispiel** Groovy open subdata searchmask **Abbildung** ![openSubdataSearchmask.PNG](https://help.cursor.de/__attachments/a_f30a0e20bc15682dd2ebad20b94b3d989ad3080b3f5bbc97e3c4544eca7b4a46/openSubdataSearchmask.PNG?cb=11fcce5c3baa3973e384619437461d9c) *** ** * ** *** ### open linked dataset from "fieldName" **Parameter** *fieldName* interner Name des Nachschlagefeldes **Aktion** Öffnet einen verknüpften Datensatz basierend auf dem angegebenen Feldnamen. Dies funktioniert nur auf Nachschlagefeldern. **Beispiel** Groovy open linked dataset from "DefaultContactPerson.Activity" **Abbildung** ![grafik-20240104-124427.png](https://help.cursor.de/__attachments/a_edb3cca7b8a9ba2022f7fc6e4f5085e1684f6ab6d76ae8003f868f6d32df9eda/grafik-20240104-124427.png?cb=78b45f8d45291732fe3f3f43b9ab4b01) ## Zuordnungsbrowser *** ** * ** *** ### assign *(all\|rows) datasets found using {searchCriteria}* **Parameter** *all\|Zahl\|Zahlenfolge*Angabe, welche Zeilen zugeordnet werden sollen * all alle Datensätze, die gefunden werden * Zahl ein Index für die Zeile, deren Datensatz zugeordnet werden soll. ![warning](https://help.cursor.de/__attachments/a_8115f0b735e1176679ea066c60adf519b379e6fdc23d1b639e85b0b3a68ffb68/atlassian-warning?cb=14432459925d605e05cae2605cdfe666) **0 ist die erste Zeile** * Bereich `Start..Ende` (z.B. `1..4`) Alle indizes zwischen Start und Ende (einschließend) * Zahl und Bereich Können kombiniert werden, z.B. `1, 4, 7 .. 13` *searchCriteria Suchkriterien für die Suche* **Aktion** Ordnet alle/einige Datensätze zu, die die Suchbedingungen erfüllen. **Beispiel** Groovy assign all datasets found using { textfield "Subject.Activity": "*" // other search criteria } // Nur bestimmte Zeilen assign 1,4,7..13 datasets found using { // Suchkriterien } *** ** * ** *** ### assign (all\|rows) datasets with attributes {*attributes* } found using {searchCriteria} **Parameter** Zusätzlich zu denen von `assign (all|rows) datasets found using {searchCriteria`}: *attributes*Werte für den Beziehungstyp **Aktion** Ordnet alle/einige Datensätze zu, die die Suchbedingungen erfüllen, und setzt den Beziehungstyp auf attributierten Relationen. **Beispiel** Groovy //Aktivitäten über den Unterbereich eines Mitarbeiters zuordnen: assign all datasets with attributes { booleanfield 'DelegatedToFlag.Activity': true lookup "RelationTypeKeyEm.Activity": "BCC" } found using { textfield "Subject.Activity": "*" // other search criteria } //Verknüpfen eines Geschäftspartners zu einem Projekt mit der Projektrolle Anlagenbetreiber: assign all datasets with attributes { lookup "ProjectRoleKey.Customer" : "ANLAGENBETREIBER" } found using { field "Name1.Customer" : "Meier" } ## Schlüssel *** ** * ** *** ### resolve key name of "somePrimaryKey" **Parameter** *somePrimaryKey* eindeutiger PK des Schlüssels **Aktion** Namen von Schlüsseln können dynamisch aus dem Testsystem ausgelesen werden und in Variablen gespeichert werden. Der jeweilige Schlüssel wird dabei über seinen Primärschlüssel identifiziert Das Keyword steht ab Version 21.2.09 zur Verfügung. Um die Verständlichkeit der Tests nicht zu beeinträchtigen, empfehlen wir, das Keyword sparsam und primär beim Modulbau in C1 einzusetzen. Übersteuerungen von C0-Schlüsseln über Anwendungsvariablen werden bei diesem Mechanismus ebenfalls berücksichtigt. **Beispiel** @Shared def aktivitaetInArbeit = resolve key name of 'S_ACTSTATUS-A' //A @Shared def strom = resolve key name of 'c51v611baip25hgS_Keytab' //01 BITTE AENDERN *** ** * ** *** ### resolve key description of "somePrimaryKey" **Parameter** *somePrimaryKey* eindeutiger PK des Schlüssels **Aktion** Beschreibungen von Schlüsseln können dynamisch aus dem Testsystem ausgelesen werden und in Variablen gespeichert werden. Der jeweilige Schlüssel wird dabei über seinen Primärschlüssel identifiziert Das Keyword steht ab Version 21.2.09 zur Verfügung. Um die Verständlichkeit der Tests nicht zu beeinträchtigen, empfehlen wir, das Keyword sparsam und primär beim Modulbau in C1 einzusetzen. Übersteuerungen von C0-Schlüsseln über Anwendungsvariablen werden bei diesem Mechanismus ebenfalls berücksichtigt. **Beispiel** @Shared def aktivitaetInArbeit = resolve key description of 'S_ACTSTATUS-A' //In Arbeit @Shared def strom = resolve key description of 'c51v611baip25hgS_Keytab' //Strom ## Warten *** ** * ** *** ### wait until field "fieldName" equals *value* \>=25.1 Gezieltes Warten auf Datensatzänderungen oder Verknüpfungen. **Parameter** *SkriptBibliothekName*Name der Skriptbibliothek, in der die zu verwendende Methode enthalten ist. *SkriptBibliothekMethodName*Name der Methode, in der das erwartete Antwortverhalten definiert ist. **Aktion** Das Test-Studio wartet bis die definierte Bedingung eintritt oder die maximale Wartezeit erreicht ist. Diese Bedingung kann ein bestimmter Feldwert, eine Feldeigenschaft oder eine Verknüpfung über den Unterbereich sein. Im Default wartet das Keyword bis zu 30 Sekunden lang und lädt die Maske dabei alle 4 Sekunden neu. Die Wartezeiten können mittels der folgenden Konfigurationen angepasst werden: 'teststudio.engine.timeout.wait.field.value.maximal.seconds=60' //Maximale Wartezeit 'teststudio.engine.timeout.wait.field.value.waitpolltime.seconds=10' //Wartezeit bis zum erneuten Laden der Maske **Beispiel** wait until field "Subject.Activity" equals "my value" wait until field "ActTypeKey.Activity" becomes mandatory wait until subdata contains dataset matching { field "DefaultCoPeAd.Address" equals false field "ZIPKey.Address" equals "DoesNotExist" } *** ** * ** *** ### wait until scriptmethod "SkriptBibliothekName.SkriptBibliothekMethodName" returns true \>=25.1 Gezieltes Warten ermöglicht das Testen von Schnittstellen zu Drittsystemen. **Parameter** *SkriptBibliothekName*Name der Skriptbibliothek, in der die zu verwendende Methode enthalten ist. *SkriptBibliothekMethodName*Name der Methode, in der das erwartete Antwortverhalten definiert ist. **Aktion** Das Test-Studio wartet bis die hinterlegte Skriptbibliotheksmethode "true" zurückgibt oder die maximale Wartezeit erreicht ist. Die Methode muss den Rückgabetype Boolean haben und unterstützt nur Parameter vom Typ String, Integer, Double oder Boolean. Außerdem muss sie mit "@BpmScript" und "@Remote" annotiert sein. Für die Autovervollständigung muss Folgendes in der Konfigurationsdatei des Test-Studios ergänzt werden: teststudio.gui.editor.autocomplete.resolve.scriptmethod.metadata=true Die Wartezeiten können mittels der folgenden Konfigurationen angepasst werden: teststudio.engine.timeout.external.scriptlibrary.maximal.seconds=30 // Maximale Wartezeit teststudio.engine.timeout.external.scriptlibrary.request.seconds=10 // Maximale Wartezeit für Auflösung Skriptbibliotheksmethode teststudio.engine.timeout.external.scriptlibrary.waitpolltime.seconds=2 // Erneutes Senden für die Auflösung der Skriptbibliotheksmethode wenn vorheriger Durchlauf abgeschlossen ist **Beispiel** wait until scriptmethod "." returns true wait until scriptmethod "." returns true using { parameter testName: "test" parameter testName2: true .... } ## Vorbereitung *** ** * ** *** Es gibt die Möglichkeit [Variablen](https://help.cursor.de/de/tstudio/current/verwendung-von-variablen-in-testfallen.md)mit bestimmten dynamischen Werten zu füllen. Diese Variablen werden nach dem Testnamen und vor dem ersten Testschritt deklariert, um diese an späterer Stelle des Testfalls verwenden zu können. ### generate unique identifier \>=24.3 Generiert einen eindeutigen Bezeichner, um diesen Variable anschließend in den Testschritten verwenden zu können. Weitere Details zur Verwendung gibt es unter [Verwendung von Variablen in Testfällen \| generate unique identifier](https://help.cursor.de/de/tstudio/current/verwendung-von-variablen-in-testfallen.md#generate-unique-identifier). ### generate unique IBAN \>=24.3 Generiert eine eindeutige IBAN. Weitere Details zur Verwendung gibt es unter [Verwendung von Variablen in Testfällen \| generate unique IBAN](https://help.cursor.de/de/tstudio/current/verwendung-von-variablen-in-testfallen.md#generate-unique-IBAN). ### resolve current date \>=24.3 Innerhalb einer Variable kann das aktuelle Systemdatum hinterlegt werden. Weitere Details zur Verwendung gibt es unter [Verwendung von Variablen in Testfällen \| resolve current date](https://help.cursor.de/de/tstudio/current/verwendung-von-variablen-in-testfallen.md#resolve-current-date). ### resolve "dateConstant" adding "relativeDate" \>=25.1 Innerhalb einer Variable kann mit Datumswerten "gerechnet" werden. Weitere Details zur Verwendung gibt es unter [Verwendung von Variablen in Testfällen \| resolve "dateConstant" adding "relativeDate"](https://help.cursor.de/de/tstudio/current/verwendung-von-variablen-in-testfallen.md#resolve-%2522dateConstant%2522-adding-%2522relativeDate%2522). ## Unterbereich *** ** * ** *** ### **'open subdata \' \| 'open subdata \ using \'** \>=25.2 Im Unterbereich können automatisch über die Option „weitere Bereiche" Datensätze einer Entität geöffnet werden, wenn diese nicht bereits eingeblendet ist. Im interaktiven Modus sollten die nicht zugeordneten Bereiche über "WEITERE BEREICHE" nicht vorab per Hand ausgeklappt werden. --- version: "current" language: "de" --- # Konfiguration und Einstellungen ## Grundlagen Wichtige Einstellungen zur Testerstellung und Ausführung werden direkt im Test-Studio unter **Einstellungen** konfiguriert: ![image2022-11-21_8-3-47.png](https://help.cursor.de/__attachments/a_c73a74de9c91ca0eac681378acf2ca0a40ca5c5159e66f314cb688ae00442646/image2022-11-21_8-3-47.png?cb=37a5642276a6848c15da7154f915d040) Vor der Testausführung werden die dafür notwendigen Einstellungen grundlegend überprüft. Im Fehlerfall wird der Nutzer aufgefordert die Einstellungen zu tätigen, bevor die Testausführung beginnen kann. ## Einstellungsgruppen und ihre Optionen ### Testeinstellungen | **Demo-Modus** | Über die Einstellungen kann der Demo-Modus aktiviert werden. Hierbei wird der Oberflächentest langsamer durchlaufen und betätigte Felder werden farblich abgehoben, so dass der Anwender jeden Schritt nachverfolgen kann. | | **Headless-mode** | Der Headless-mode startet den Browser ohne Oberfläche und lädt nur die Website. D.h. das Browser-Fenster wird nicht geöffnet und der Test läuft vollständig im Hintergrund. | |-------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| ### Testsystem Login Hier wird das System konfiguriert, auf dem die Tests ausgeführt werden. | **URL zum Web-Client des Testsystems** | Auf diesem System | | **Benutzer** | Benutzer, unter dem die Tests ausgeführt werden. Mit diesem Benutzer meldet sich das TestStudio am WebClient an. * Diesem Benutzer muss das Aktionsrecht "GUI-Testfälle ausführen" gewährt werden. Im Standard sind dies alle Administratoren. * Der Zen-Modus muss für den User deaktiviert sein. | | **Passwort speichern** | Soll das Passwort in maskierter Form gespeichert werden? Das Deaktivieren dieser Option löscht ein eventuell bereits gespeichertes Passwort. | | **Passwort** | Passwort für oben stehenden Benutzer. Optional im interaktiven Modus (beim Testentwickeln). Muss gesetzt sein, wenn die Tests im Batch-Modus ausgeführt werden sollen. | |----------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| ### Testausführung (Selenium) Hier werden der Browser und weitere Einstellungen zur direkten Testausführung konfiguriert. | **Browser** | Der Browser für die Testausführung. Dieser muss auf dem System installiert sein. Ggf. gibt es bei einzelnen Browsern Funktionseinschränkungen. Die Tests können aktuell in den folgenden Browsern ausgeführt werden: Google Chrome, Microsoft Edge (nur der Chromium-Basierte Edge) oder Mozilla Firefox | | **Wartezeit** | Nach jeder Aktion im WebClient (z.B. Mausklicks, Eingaben in Felder, Starten von Prozessen) wird gewartet, bis der WebClient bereit für die nächste Aktion ist (z.B. bis die Prozessmaske offen ist). Dies ist die maximale Wartezeit dafür. Wird sie überschritten, bricht der Test ab. | |---------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| **Warnung - WebDriver notwendig** Zur Testausführung wird der passende "WebDriver" benötigt. Der WebDriver fungiert als "Klebstoff" zwischen Test-Studio und dem Browser: Dadurch wird es dem Test-Studio überhaupt erst möglich, dem Browser Befehle wie "Klicke auf diesen Button/Schalter" zu übermitteln. Weitere Informationen zum Installieren des passenden WebDrivers unter "Menüeinträge" auf dieser Seite. ### CRM-Login (in dieses System werden die Testergebnisse/Reports geschrieben) Dieser Abschnitt konfiguriert die Integration der Testergebnisse, die unter [Architektur](https://cursorhelp.atlassian.net/wiki/pages/createpage.action?spaceKey=TSTUDIO2&title=Architektur%20des%20CURSOR%20Test-Studios) geschrieben ist. | **URL** | Das System, in das die Reports geschrieben werden. | | **Benutzername** | Benutzer für das Report-System. | | **Passwort** | Passwort für oben genannten Benutzer. Muss gesetzt sein, wenn die Tests im Batch-Modus ausgeführt werden sollen. | | **Gemeinsames Verzeichnis** | Pfad, in den Dateien abgelegt werden, die von den zurücksynchronisierten Ergebnissen benötigt werden. | |-----------------------------|------------------------------------------------------------------------------------------------------------------| ### Test-Studio (GUI) spezifische Einstellungen Hier sind Einstellungen zu finden, die das Entwickeln der Tests angenehmer machen. Sie haben keinen Einfluss auf die Ausführung der Tests. | **Theme** | Erscheinungsbild des Test-Studios. Entweder "hell" oder "dunkel". | | **Horizontale Verschiebung des Test-Browsers ("X window offset")** | Verschiebt das Browser-Fenster beim Start um den angegebenen Wert (negativ = links, positiv = rechts). Dadurch kann der Browser immer auf einem bestimmten Monitor geöffnet werden. | |--------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| ## Menüeinträge ### WebDriver Hier können die WebDriver für Google Chrome, Microsoft Edge (nur der Chromium-Basierte Edge) oder Mozilla Firefox aktualisiert werden. Ggf. sind weitere technische Berechtigungen erforderlich, um den Webdriver automatisiert downloaden zu können. Alternativ kann er durch einen Administrator auch manuell bereitgestellt werden. Weitere Informationen: [Installation und Update \| WebDriver und Browser](https://help.cursor.de/de/tstudio/current/installation-und-update.md#WebDriver-und-Browser) ### Erweitert Fortgeschrittene Einstellungen, die normalerweise nicht von Interesse sein sollten. --- version: "current" language: "de" --- # Nutzerwechsel im Test-Studio ## Motivation Für das vollständige Durchtesten von Prozessen ist es unter Umständen notwendig, das Resultat mit einem weiteren Nutzer als dem durchführenden zu verifizieren oder Kommunikation zwischen Nutzern zu überprüfen. ## Vorbereitung Der Nutzerwechsel im Test-Studio basiert auf der Stellvertreteranmeldung. Dies war eine bewusste Entscheidung, um unter anderem das Speichern weiterer Passwörter zu vermeiden. Aufgrund dessen ist es notwendig alle zusätzlich verwendeten Mitarbeiter dem in der Anwendung hinterlegten Hauptnutzer als Stellvertreter zuzuordnen, bevor diese im Test-Studio für den Nutzerwechsel verwendet werden können. Dies muss von Ihrem Administrator durchgeführt werden. Im Anschluss müssen Sie die Stellvertreter im Test-Studio hinterlegen. Hierfür finden Sie unter Einstellungen einen neuen Sektor namens 'Nutzerwechsel'. Über den Button 'Alias hinzufügen' können Sie nun Stellvertreter hinterlegen. Des Weiteren können Sie bestehende Stellvertreter bearbeiten oder entfernen. ![NutzerwechselVerwaltungGUI.PNG](https://help.cursor.de/__attachments/a_75323c0487dd51098b27ab4a9ee512a88fc85482b8386d083c8133a157c71454/NutzerwechselVerwaltungGUI.PNG?cb=6474e7cf4631469c47f3000110fa3135) Der Name des Alias dient zur Identifizierung und kann frei gewählt werden. Der Alias-Wert muss jedoch mit dem Vor- und Nachmanen des verwendeten Stellvertreters übereinstimmen. Der Name wird später zur eindeutigen Selektion in der Stellvertreterauswahl des Webclients genutzt. Falls sich Einträge in der Tabelle nicht bearbeiten oder löschen lassen, wurden diese von Ihrem Administrator vorbelegt. Infos hierzu finden sie unter dem Kapitel -- **Administrative Vorgabe von Einstellungen**. ## Ausführung Der Nutzerwechsel wird mit Hilfe der unten dargestellten Angabe '@SwitchUser(alias= 'administrator') oberhalb eines Testschrittes genutzt. Groovy @SwitchUser(alias = 'administrator') def "switch to administrator and assert"() { given: open entity "Activity" create dataset field "DelegatedTo.Activity" should be "Admin Admin" close level and discard } Die Angabe bewirkt, dass ab der Verwendungsstelle und damit vor dem damit markiertem Testschritt ein Nutzerwechsel durchgeführt wird. Das heißt, alle folgenden Testschritte werden unter diesem neuen Nutzer ausgeführt. In einem Testfall ist es darüber hinaus möglich mehrmals den Nutzer zu wechseln und auch wieder zurück zum "Default", den unter Einstellungen konfigurierten Standardnutzer, zurückzuwechseln. Groovy @SwitchUser(alias = 'administrator') def "switch to administrator and assert"() { given: open entity "Activity" create dataset field "DelegatedTo.Activity" should be "Admin Admin" close level and discard } @SwitchUser(alias = 'sachbearbeiter') def "switch to sachbearbeiter and assert"() { given: open entity "Activity" create dataset field "DelegatedTo.Activity" should be "Sachbearbeiter Sachbearbeiter" close level and discard } @SwitchUser(alias = 'default') def "switch back to default user"(){ given: open entity "Activity" create dataset field "DelegatedTo.Activity" should be "Default Default" close level and discard } Der Wechsel zurück zum Standardnutzer wird mit Hilfe der Angabe ' @SwitchUser(alias = 'default') ' durchgeführt. Würde im oberen Testfall der Wechsel zum Stellvertreter Sachbearbeiter fehlen, würde dieser Testschritt ebenfalls mit dem Mitarbeiter Administrator durchgeführt werden. Im interaktiven Modus erscheint vor jedem Nutzerwechsel zu einem nicht bereits gewechselten Nutzer ein Dialog. Diesen können Sie in den Einstellungen ausschalten und bewirken damit, dass immer ein Nutzerwechsel im interaktiven Modus durchgeführt wird, wenn sich das Keyword unterhalb eines abweichenden Nutzer befindet. --- version: "current" language: "de" --- # Protokollansicht ## Protokoll-Menü ### Export ![grafik-20240115-120646.png](https://help.cursor.de/__attachments/a_45fe21de22fc96de563934de11cd69f4da296632fed6e3142b1ec5beafe31706/grafik-20240115-120646.png?cb=6e2b63822d1eb31151f0a45f304b2de2) * Protokoll speichern = Speichert das Protokoll an einem beliebigen Ort ab. * Protokoll in CRM speichern = Das Protokoll wird in CURSOR-CRM, EVI oder TINA abgespeichert. ### Protokoll ![grafik-20240115-120602.png](https://help.cursor.de/__attachments/a_a33c65f4fafe79f94089cdfe4afdddb3460fa0d643c053c2b2e01c457d2ed8c5/grafik-20240115-120602.png?cb=80aa71cac8f67a917b90df5697ed6036) * Protokoll in neuem Fenster öffnen = Öffnet das Protokoll in einem neuen Fenster * Protkoll(e) aktueller Ansicht hinzufügen = Öffnet das Protokoll ### Darstellung ![grafik-20240117-115928.png](https://help.cursor.de/__attachments/a_63fa57b19d8ffd6752031d7cdd6bc34678c8afbef30e8dbe367a4c5883126267/grafik-20240117-115928.png?cb=f6a6af4de4fc91f49fde179d19e85d31) Nach: * Ausführungsreihenfolge = Stellt die Ausführungsreihenfolge im Protokoll her und zeigt die Testfälle in der Reihenfolge an, in welcher sie ausgeführt wurden. * Ordnerstruktur = Stellt die Ordnerstruktur im Protokoll wieder her und zeigt die Testfälle in der Ordnerstruktur, in welcher sie zur Ausführungszeit vorlagen. * Nach Testfällen = Ordnet alle gleichen Testfälle mit dem gleichen Pfad in einem eigenen Protokollknoten ein und zeigt diese somit nach Testfällen gruppiert im Protokoll an. → Nur fehlgeschlagene Tests anzeigen = Zeige nur fehlgeschlagene Testfälle im Protokoll an. → Übersprungene Testschritte anzeigen = Zeige übersprungene Testschritte im Protokoll an. → Ordner zusammenfassen = Fasst die Testfälle nach Testverzeichnissen zusammen → Auf WorkSpace normalisieren = Interessant wenn, mehrere Protokolle geöffnet sind. Die Option fasst beide Protokolle so behandlet, als würde alle im selben WorkSpace anfangen; d.h. der Pfad davor wird entfernt. ### Suche Öffnet einen Dialog, welcher die Suche im Protokoll ermöglicht. ![grafik-20240115-120825.png](https://help.cursor.de/__attachments/a_08b53528cc99212cdbda8ccebd39f997823527279a4c6490f994e4696011872c/grafik-20240115-120825.png?cb=da9e77aa0aa63367b2faf88a6c7fa281) ### Protokoll leeren Öffnet einen Dialog, über den das Löschen bestätigt werden kann. Wird dieser bejahrt, werden alle Aufzeichnungen der Testdurchläufe in der aktuellen Sitzung gelöscht. ![grafik-20240115-120914.png](https://help.cursor.de/__attachments/a_833a5e304879722ec3cc43c9bf221c1603de23bf19f416fcb9ed71a59cdf086b/grafik-20240115-120914.png?cb=b46a8e16c501832813f74d10b795d967) ## Protokoll-Unterbereich ### Details anzeigen Die Details geben dem Anwender eine Übersicht über Status, Start- und Endzeitpunkt sowie Aktionsdauer des aktuell ausgewählten Knotens. ![image2022-11-3_10-33-33.png](https://help.cursor.de/__attachments/a_c3d561f1000d940be03f82f1376b70a6f32321ee917c1e9c562c73b6a33830fd/image2022-11-3_10-33-33.png?cb=5e74e35aa1bd1103e430a797f7072a71) ### Screenshot anzeigen Zu einem Testschritt, der einen Fehler verursacht hat, gibt es einen Screenshot, der die Oberfläche zum Zeitpunkt indem der Fehler auftritt, festhält. ![image2022-11-3_10-32-20.png](https://help.cursor.de/__attachments/a_717c541273440ce15c9b20bc12bec5ac9a9dba740986c158dd24eb4147372365/image2022-11-3_10-32-20.png?cb=d019313706fae9f51c58adcd43b06fd0) ### StackTrace anzeigen Über das StrackTrace kann eine detaillierte Fehlermeldung aufgerufen werden. Beispiel: ![image2020-3-11_16-42-57.png](https://help.cursor.de/__attachments/a_1bb6737ddbf506975cc2583aa85dd17eb3762a0085fdc62aa0ab405ce6e22f88/image2020-3-11_16-42-57.png?cb=748047ad2dab63d33900fd997a85297d) Es ist zu erkennen, dass das Feld mit dem technischen Feldnamen `Reference.Quote` laut Testschritt ein Pflichtfeld (`expected == mandatory`) sein soll, der Test hat jedoch ergeben, dass es dies nicht ist (`getMetaValue() == nonmandatory`). In Zeile 41 des Testfalls "NeuesAngebot", innerhalb des Testschritts "Prüfe Initialwerte" befindet sich die Unstimmigkeit. Manchmal ist es schwer, aus dem StackTrace auf den Fehler zu schließen. Oft ist auf dem Screenshot besser zu erkennen, wo das Problem liegt. --- version: "current" language: "de" --- # Quick Start Guide Das Test-Studio wird passend zur CRM-Version mit dem Client ausgeliefert. Somit ist keine separate Installation erforderlich. Diese Doku gibt einen Überblick, über die wichtigsten Punkte, die innerhalb des Studios eingerichtet werden müssen, um mit der Testfallerstellung schnellstmöglich starten zu können. ## Vorbereitung * Im CRM ist eine gültige Test-Studio-Lizenz vorhanden. * Der Zugang zu einem Test-Studio liegt vor. ( ...\\client\\jboss\\teststudio\\CURSOR_TestStudio.exe) * Das Test-Studio kann nur mit dem QS- oder Entwicklungssystem verknüpft werden. Welches System soll getestet werden? → Link zum Webclient bereithalten. * Unter welchem CRM-User sollen die Tests durchgeführt werden? ![info](https://help.cursor.de/__attachments/a_e97631208f1da053cf024e9c0d34af352f4c304a896338d9a4c586016e37a615/atlassian-info?cb=feab5cd71111204d6b52545f3027dd0c) Bedingungen für den User: [Installation und Update \| CRM Systeme](https://help.cursor.de/de/tstudio/current/installation-und-update.md#CRM-Systeme) → Nutzername und Passwort bereithalten. * Optional: In welches CRM sollen die Testergebnisse geschrieben werden? → Link zum Webclient, sowie User und Passwort bereithalten. ## Test-Studio öffnen und Einstellungen anpassen 1. Link, User und Passwort zu dem zu testenden System hinterlegen. 2. Gewünschten Browser für die Testausführung (Edge, Chrome, Firefox) wählen. 3. Optional: Link, User, Passwort zum System, in welches die Testergebnisse (Reports) geschrieben werden sollen, hinterlegen. 4. Webdriver-Download über den Reiter "Webdriver" starten. Ist der automatische Download aufgrund von Sicherheitsrichtlinien nicht erlaubt, kann die manuelle Hinterlegung analog vorgenommen werden. ## Neuen Workspace erstellen Das Test-Studio ist nun vollständig eingerichtet. Über die Option "Neuen Workspace erstellen" kann jetzt ein neues Verzeichnis zur Testerstellung erstellt werden und die Testautomatisierung kann beginnen. Alle Details zum Umgang mit dem Studio sind in der [Anwenderdokumentation](https://help.cursor.de/de/tstudio/current/anwenderdokumentation.md) aufgeführt. ![info](https://help.cursor.de/__attachments/a_e97631208f1da053cf024e9c0d34af352f4c304a896338d9a4c586016e37a615/atlassian-info?cb=feab5cd71111204d6b52545f3027dd0c) Selbstverständlich unterstützen wir beim Einstieg auch gerne durch unsere Schulung oder individuelle Workshops. Hier wird nur die Einrichtung des Studios für die Erstellung von Testfällen und zum manuellen Start von Testläufen beschreiben. Um erstellte Testfälle auch automatisiert ausführen zu können sind weitere Schritte notwendig, welche unter [Regelmäßiges Ausführen der Tests](https://help.cursor.de/de/tstudio/current/regelmaiges-ausfuhren-der-tests.md) genau dokumentiert sind. --- version: "current" language: "de" --- # Regelmäßiges Ausführen der Tests ## Grundlagen Um eine Vielzahl an Tests regelmäßig, z.B. jede Nacht, auszuführen, gibt es den Batch-Runner. Diese führt alle Testfälle eines Workspaces im "Headless"-Modus aus. "Headless" heißt, dass kein Browser-Fenster zu sehen ist und die Tests im Hintergrund ausgeführt werden. ## Vorgehensweise Mittels der Windows Aufgabenplanung kann mit wenig Aufwand eine regelmäßige Ausführung der Tests erreicht werden. Die erforderlichen geplanten Tasks können mithilfe des PowerShell-Skripts `\teststudio\scheduledTasks\createScheduledTestExecution.ps1` erstellt werden. Beispiel: .\createScheduledTestExecution.ps1 -workspaceFolder C:\myWorkSpace -reportFolder C:\myReports -pushResultsIntoCrm $False -replaceExistingTask $False Die vollständige Dokumentation zu diesem Skript kann über Get-Help .\createScheduledTestExecution.ps1 createScheduledTestExecution.ps1 [-workspaceFolder] [-reportFolder] [-pushResultsIntoCrm] [-replaceExistingTask] [] eingesehen werden. Der erstellte geplante Task erfordert weitere Konfiguration: * Der Trigger bzw. Zeitplan muss angepasst werden. * Unter "Sicherheitsoptionen" sollte ein technischer Benutzer (oder Service User, gMSA) hinterlegt werden. Diesem muss -- wie bekannt -- das Recht "Anmelden als Stapelverarbeitungsauftrag" gewährt werden. Wird ein "gruppenverwaltetes Dienstkonto" (gMSA) verwendet, sollte für dieses Konto das `%WORKING_DIR%` des Test-Studios an einen Speicherort außerhalb von `%APPDATA%` verschoben werden: IF /i "%COMPUTERNAME%" == "MY-MACHINE" ( SET WORKING_DIR=d:\CURSOR\test-studio\working_dir ) REM oder IF /i "%USERNAME%" == "$gMSA_User$" ( SET WORKING_DIR=d:\CURSOR\test-studio\working_dir ) IF NOT DEFINED WORKING_DIR ( SET WORKING_DIR=%APPDATA%\CURSOR\testStudio ) Im `%WORKING_DIR%` werden neben Einstellungen auch Log-Dateien abgelegt, die für die Fehlersuche hilfreich sind. Hintergrund ist, dass dieses Konto nur mit einem temporären `%APPDATA%`-Verzeichnis für die Laufzeit des geplanten Tasks ausgestattet wird. ### Regelmäßige Aktualisierung der WebDriver Über das PowerShell-Skript `\teststudio\scheduledTasks\createUpdateBrowserTask.ps1` kann analog ein geplanter Task zur regelmäßigen Aktualisierung des WebDrivers erstellt werden. Auch dieser erfordert weitere Konfiguration. ## Hilfe Der Batch-Runner hat eine eingebaute Hilfe, die über `CURSOR_TestStudio_batch -h` zugänglich ist: PowerShell Usage: TestStudioCli [-hV] [COMMAND] -h, --help Show this help message and exit. -V, --version Print version information and exit. Commands: update-driver Updates the driver for the specified browser(s). execute-test-workspace Executes all tests in a given workspace. ## Rückgabewerte des Batch-Runners Der Batch-Runner liefert verschiedene Return-Codes zurück, die eine schnelle Ergebnisbegutachtung zulassen. | **Code** | **Bedeutung** | |----------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | 0 | Alle Tests erfolgreich ausgeführt oder WebDriver erfolgreich aktualisiert. | | 1 | Es gab fehlgeschlagene Tests. | | 2 | Die übergebenen Aufrufparameter für den Batch-Modus sind ungültig. | | 3 | Die Testausführung wurde wegen eines schwerwiegenden, internen Fehlers abgebrochen. Weitere Informationen sind im Log zu finden. | | 4 | Die Testausführung wurde abgebrochen, weil mindestens eine Testschrittbibliothek oder ein Testfall Syntaxfehler enthält. | | 5 | Das Protokoll der Testausführung kann/konnte nicht gespeichert werden. Dieser Fehler kann vor der Testausführung auftreten, wenn geprüft wird, ob das Protokoll prinzipiell gespeichert werden könnte oder hinterher, wenn das Protokoll wirklich gespeichert wird. | | 11 | Keine Testfälle im Workspace gefunden. | | 12 | Die gespeicherten Login-Daten für das Test-CRM sind fehlerhaft. | | 13 | Die gespeicherten Login-Daten für das Report-CRM sind fehlerhaft. | | 14 | Das Test-System ist für die Ausführung von Tests ungeeignet (z.B. Produktivsystem) | | 15 | Das Update des WebDrivers ist fehlgeschlagen. | | 16 | Die zur Testausführung notwendige Konfiguration ist nicht vorgenommen worden. | | 17 | Das zur Testausführung notwendige Aktionsrecht wurde dem Benutzer nicht gewährt. | | 18 | Keine Modullizenz für das Test-Studio im CRM vorhanden. | --- version: "current" language: "de" --- # Relative Datumsangaben Um dynamisch innerhalb eines Testlaufs Datumswerte setzen zu können, gibt es die Möglichkeit relative Datumsangaben innerhalb des Testfalls zu verwenden. ## Aufbau einer relativen Datumsangabe * `"d"` → x Tage (4d: 4 Tage) * `"w"` → x Wochen (3w: 3 Wochen) * `"m"` → x Monate (2m: 2 Monate) * `"y"` → x Jahre (1y: 1 Jahr) * bei einer Kombination werden die einzelnen Bestandteile nacheinander angewendet: "4d2m" → 4 Tage und 2 Monate ### Verwendung innerhalb eines Testfalls Die relative Datumsangabe kann im Keyword zum Setzen von Feldwerten verwendet werden, indem sie mit der Erweiterung "adding" hinzugefügt wird: * `set field "" to "" adding ""` * `fill mask using` { `field "": "" adding ""` } **Beispiel** set field "TestDate.TestEntity" to "${DATE}" adding "4d" field "TestDate.TestEntity" should be "12.02.2024" Auch das Keyword zur Feldprüfung kann mittels "adding" um die relative Datumsangabe erweitert werden: * `field "" should be "" adding "` **Beispiel** set field "TestDate.TestEntity" to "12.04.2024" field "TestDate.TestEntity" should be "08.04.2024" adding "4d" --- version: "current" language: "de" --- # Release-Notes für das CURSOR-Test-Studio **Anmerkungen zu den Test-Studio-Release-Dokumentationen** Mit Versionen 24.1 wurde die Entwicklung des Test-Studios in den Entwicklungsstrang des CRMs integriert. Durch die feste Verankerung der CRM-Version mit der Test-Studio-Version wird sichergestellt, dass beide Systeme immer perfekt aufeinander abgestimmt sind. Außerdem findet ein Test-Studio-Update im Rahmen des CRM Updates automatisch statt. Somit liegt immer die passende neuste Test-Studio-Version vor, ohne dass diese explizit angefordert werden muss. Deshalb sind ab sofort alle Änderungen und Neuerungen zum Test-Studio in der allgemeinen [CRM Release-Dokumentation](https://help.cursor.de/de/hub/current/release-dokumentation) enthalten. Alle Punkte, die das Test-Studio betreffen sind in den Patch-Notes zur jeweiligen Version mit der Komponente "Teststudio" markiert. --- version: "current" language: "de" --- # Sperrkonzept Workspace ## Grundlagen Ohne ein Sperrkonzept ist es möglich, dass Änderungen durch gleichzeitig arbeitende Anwender überschrieben werden. Deshalb sperrt das Test-Studio den Workspace für andere Test-Studios, solange es diesen geöffnet hat. Falls Sie einen gesperrten Workspace öffnen, erhalten Sie, insofern möglich, eine Meldung mit dem sperrenden Nutzer. Dadurch können Sie ihn kontaktieren und sich besser absprechen. Möglich ist dies mit Hilfe einer ".workspaceLock"-Datei welche vom Test-Studio beim Öffnen angelegt oder wenn vorhanden für das Sperren verwendet wird. Zusätzlich finden Sie eine ".workspaceLockInfo"-Datei nach dem Öffnen innerhalb eines Workspaces. In dieser Datei finden Sie den Namen des Nutzers, welcher zuletzt den Workspace gesperrt hat. ## Hilfe Falls Sie einen Workspace nicht mehr öffnen können, obwohl Sie sichergestellt haben, dass niemand diesen geöffnet hat, wechseln Sie in den Workspace Ordner und löschen Sie die beiden oben beschriebenen Dateien. Falls Sie die Dateien im Workspace-Verzeichnis nicht auffinden können, stellen Sie sicher, dass im Explorer die Ansicht "Ausgeblendete Elemete anzeigen" auch aktiviert ist. Falls Sie die Datei ".workspaceLock" nicht löschen können, ist diese noch durch einen Test-Studio Prozess gesperrt. Bitte starten Sie die relevanten Systeme neu, um hinterbliebene Prozesse aufzuräumen. --- version: "current" language: "de" --- # Technischer Kommunikationsplan der CURSOR-Test-Studio Komponenten ![grafik-20240104-065052.png](https://help.cursor.de/__attachments/a_d02d02c6edd643e5c417a720d8a39f925baff46f38efd3642d8cea3ace2c5413/grafik-20240104-065052.png?cb=7c99f55c5ade3c56671d549b1ad6460f) **WebDriver-Updater** Wenn die WebDriver manuell aktualisiert werden, muss der WebDriver-Updater nicht verwendet werden. ## Logins Alle Kommunikation (Anmeldung am WebClient, REST-API ...) mit dem Test-CRM erfolgt mit den Anmeldedaten des Testbenutzers. Für jegliche Kommunikation mit dem Report-CRM (kann identisch zum Test-CRM sein) werden die Anmeldedaten des Reportbenutzers genutzt. --- version: "current" language: "de" --- # Testergebnisse im CRM ## Grundlagen Standardmäßig werden Testergebnisse als Protokolldateien in einem eigenen Format `teststudio_log` gespeichert. Um einen direkten Überblick über die Testsituation (z.B. "Wie viele Testfälle sind letzte Nacht fehlgeschlagen?") zu bekommen, können diese in ein CRM-System zurück synchronisiert werden. Die Testergebnisse werden auf Datenbankebene in der Entität "Testläufe" gespeichert. Screenshots werden als Dokumentdatensätze vom Typ LINK angelegt (weitere Informationen finden Sie im Kapitel [Systemlandschaft für das Test-Studio](https://help.cursor.de/de/tstudio/current/installation-und-update.md#Systemlandschaft-f%25C3%25BCr-das-Test-Studio)). Übertragen wird dabei nur eine Zusammenfassung, im Fehlerfall zusätzlich die Stelle, an der der Fehler auftrat. Weitere Details sind dem verlinkten Protokoll zu entnehmen. ## Ablageort im CRM Im Bereich Administration sind Testläufe unter dem Menüpunkt "Laufzeitdaten" zu finden. ![image2022-10-26_14-38-10.png](https://help.cursor.de/__attachments/a_618d2fa11eaff692954d65c1bef67033a831309684eacbfffc27431a8d675ab0/image2022-10-26_14-38-10.png?cb=c2a1f769dc7bb19e3403140b3ff25482) ![image2022-10-26_14-39-29.png](https://help.cursor.de/__attachments/a_419d8fde5bc5f5715dd4c45d3d51b2f4ed4b66465c2b5289be10b8924daf86d1/image2022-10-26_14-39-29.png?cb=2e93b11ccd94a24464fcd00fe753c607) ## Konfiguration Das System, in das die Testergebnisse eingetragen werden sollen muss in den Einstellungen des Test-Studios hinterlegt werden. Weitere Informationen siehe [Konfiguration und Einstellungen](https://help.cursor.de/de/tstudio/current/konfiguration-und-einstellungen.md). ## Der manuelle Weg Ein einzelner Report kann direkt aus dem Test-Studio in das CRM übertragen werden: 1. Das Protokoll im Test-Studio öffnen 2. Die Aktion Export öffnen 3. *Protokoll in CRM speichern* auswählen ![image2022-10-26_14-40-56.png](https://help.cursor.de/__attachments/a_1f77eec0cc6d103c451aefcd16cbeeeb981bc84e88655f9ab50c075efc89fda8/image2022-10-26_14-40-56.png?cb=31a116c104f391db4878da88a50b0c90) ## Der automatische Weg Der Batch-Runner kann am Ende der Testausführung die Ergebnisse in das CRM speichern. Weitere Informationen dazu finden Sie unter [Regelmäßiges Ausführen der Tests](https://help.cursor.de/de/tstudio/current/regelmaiges-ausfuhren-der-tests.md)[.](https://help.cursor.de/de/tstudio/current/regelmaiges-ausfuhren-der-tests.md) --- version: "current" language: "de" --- # Testschrittbibliothek ## Grundlagen Die Testschrittbibliothek stellt ähnlich zur Skriptbibliothek des CRMs für die automatisierten Oberflächentests eine Bibliothek zur Verfügung, in der verschiedenste Testschrittmethoden erstellt werden können. Durch die Einführung der Testschrittbibliothek können identische Testschritte in den verschiedenen Testfällen nun an einer Stelle in der Testschrittbibliothek bearbeitet werden. Die Änderung der Testschrittmethode greift dann in allen Testfällen, in denen diese Testschrittmethode verwendet wird. Ein anschauliches Beispiel ist das Ändern eines Pflichtfeldes auf der Geschäftspartnermaske. Ohne die Testschrittbibliothek müsste der Anwender des Test-Studios jeden einzelnen Testfall bearbeiten, indem eine Pflichtfeldprüfung auf der Geschfäftspartner-Maske vorgenommen wird. Mit der Testschrittbibliothek muss der Anwender nur die eine Stelle in der Testschrittmethode anpassen. Die Änderung wird dann in den einzelnen Testfällen durch den Aufruf der Testschrittmethode übernommen. ## Vorteile der Testschrittbibliothek * Testfälle werden insgesamt übersichtlicher. * Zentrale Methoden erleichtern das Schreiben neuer Testfälle. * Die Wartbarkeit der Testfälle wird erhöht, denn es muss nur noch an wenigen, im besten Fall an einer Stelle, Anpassungen vorgenommen werden. * Fehleranalyse wird vereinfacht, da sofort sichtbar ist wenn eine zentrale Methode in mehreren Tests Fehler verursacht. ## Konzept und Einschränkungen * Es wird ein Workspace als definierte Einheit von Testschrittbibliothek (Lib) und Testfällen (Test) eingerichtet. * Empfehlung: Ein Workspace pro Unternehmen / CRM System * Parameter; String-basiert * Hinweis für Administratoren (Programmierer): * Keine Return Values möglich, nur Aufrufen von Bibliotheken * Keine globalen Variablen `@Shared def ...` in Bibliotheken ## Best Practices ### Namensgebung * Testfällen, -methoden und -schritten sollten `CamelCase` konforme Bezeichner erhalten. Bei der Benennung sind Unterstriche ( `_` ) zu vermeiden. * Testklassen müssen mit einem Großbuchstaben beginnen, bspw. `CustomerUtils` * Testmethode müssen hingegen mit einem Kleinbuchstaben beginnen bspw. `createCustomerSubdata` * Der Testfall heißt wie die Datei. Dies wird durch den Editor so vorgegeben. Hier dürfen keine Leer- oder Sonderzeichen verwendet werden. Auf Abweichungen weist der Editor deutlich hin. ### Aktionen einer Testschrittbibliotheksmethode * Wenn in einer Methode eine neue Ebene oder Verlaufseintrag im CRM geöffnet wird, sollte der Anwender am Ende der Methode wieder auf der gleichen Ebene bzw. Maske stehen wie vor dem Start der Methode. ### Dokumentation * Methoden in der Testschrittbibliothek sollten mit Kommentarblöcken dokumentiert werden: Java /** * Hier steht, was die Methode macht. * * @param meinParameter Dieser Parameter wird von der Methode gebraucht. */ Diese Dokumentation steht später auch über die Autovervollständigung zur Verfügung. Das Dokumentationsformat orientiert sich an JavaDoc. * Bei Methoden, die auf BPM-Prozessmasken arbeiten, sollte der technische Namen der Maske in die Beschreibung aufgenommen werden. ### Protokoll ![image2022-11-3_10-21-44.png](https://help.cursor.de/__attachments/a_41729b62734cdc1775b5e9a422d50241d2e17726ddfc0f904d1df429598a4228/image2022-11-3_10-21-44.png?cb=30702aaee846d6f478a15c6b62d591bb) * Dem Protokoll kann entnommen werden, wann eine Testschrittmethode aufgerufen wurde → *execute Bibliotheksname.Testschrittmethode* * Unterhalb der Testschrittmethode sind die einzelnen Schritte der Methode zu entnehmen ## Interaktiver Modus Detaillierte Informationen zum interaktiven Modus sind hier zu finden: [Interaktiver Modus](https://cursorhelp.atlassian.net/wiki/pages/createpage.action?spaceKey=TSTUDIO2&title=.Interaktiver%20Modus%20v1.5.0). Durch die Testschrittbibliothek sind folgende Besonderheiten zu beachten: * Einzelne oder mehrere Keywords können sowohl im Testfall als auch in der Bibliothek ausgeführt werden. Dafür sind -- wie bisher in Testfällen auch -- nur die auszuführenden Keywords einer Testschrittmethode zu markieren. * Besitzt die Methode Parameter, so werden die Werte erfragt, die in dieser interaktiven Ausführung genutzt werden sollen. Bei parameterlosen Methoden entfällt der Schritt. ![image2022-6-14_12-56-30.png](/__attachments/a_bd70673ebecf5470bf9bd41d42d80f1ec58b242cfbb583ca026ee0b333638d11/image2022-6-14_12-56-30.png?cb=1cc40951426d9294722c53c6f44df789) * Breakpoints können nur in einem Testfall gesetzt werden. Ein Breakpoint kann *nicht* innerhalb einer Testschrittmethode gesetzt werden. * Um dennoch einzelne Keywords einer Methods auszuführen, bietet sich folgendes Vorgehen an: * Breakpoint vor die Aufrufstelle der Methode im Testfall setzen. * Anschließen innerhalb der Methode die Keywords markieren und mittels "Auswahl ausführen" ausführen. * Sollte die Methode Parameter haben, so werden deren Werte abgefragt. Welcher Wert für den Parameter eingesetzt werden soll, ist dem unteren Bereich des Test-Studios mit der Auflistung aller verwendeter Parameter zu entnehmen. * Die Keywords werden interaktive ausgeführt und tauchen im Protokoll auf. * Die definierten Variablen aus dem Haupttestfall stehen (weiterhin) zur Verfügung. --- version: "current" language: "de" --- # Umstellung Lesemodus ## Motivation Mit der Einführung des Lesemodus in Version 23.2 ändert sich der Arbeitsablauf in unserem CRM. Da das Teststudio genau diesen Arbeitsablauf abtestet, müssen bestehende Tests angepasst werden. Der weiter unten folgende Text soll Ihnen als Unterstützung dienen und zeigen, dass die Umstellung Ihrerseits nicht viel Arbeit erfordert. ## Neuerungen Die Anpassung soll für Sie möglichst angenehm sein und deshalb haben wir zwei neue Keywords "enter read mode" und "enter edit mode" entwickelt. Mit Ersterem betätigen Sie den Schalter "Lesen" und gelangen somit in den Lesemodus, falls Sie sich im Bearbeitungsmodus befunden haben. In diesem können Sie wie gewohnt alle angezeigten Felder z.B. mit 'field "Subject.Activity" should be "value" ' überprüfen. Genauso können Sie hier gewisse Metavalidierungen von Feldern wie 'field "Subject.Activity" should be visible' abtesten. Dennoch empfiehlt es sich, für die Metavalidierung in den Bearbeitungsmodus zu wechseln, besonders für 'mandatory/ enabled/ blank'. Denn wie Sie wissen, werden leere Felder im Lesemodus nicht dargestellt und damit kann das Teststudio diese auch nicht überprüfen! Für genau diesen Fall können Sie mit dem zweit genannten Keyword "enter edit mode" in den Bearbeitungsmodus wechseln. In diesem ändert sich für Sie nichts und alle Funktionen des Teststudios stehen wie gewohnt zur Verfügung. Die Bearbeitung im Lesemodus ist derzeitig noch nicht möglich, unsererseits jedoch für die Zukunft geplant. Deshalb gilt es bei bestehenden Testfällen darum, den notwendigen Wechsel in den Bearbeitungsmodus zu finden und zuvor das Keyword "enter edit mode" zu nutzen. ## Wechsel in den Bearbeitungsmodus Typische Fälle für den Wechsel in den Bearbeitungsmodus sind: * Sie möchten einen bestehenden Datensatz bearbeiten * Sie führen Metavalidierungen wie "enabled" durch * Sie möchten leere Felder überprüfen ## Vorgehen Generell können Sie versuchen diese Fälle ohne Ausführung zu erkennen und vor der Prüfung in den Bearbeitungsmodus wechseln. Intern hat sich jedoch der interaktive Modus hier als das Mittel der Wahl erwiesen. Mit diesem empfiehlt es sich komplexere Testfälle einmal zu durchlaufen und wenn der Funktionsaufwand des Lesemodus nicht ausreicht, in den Bearbeitungsmodus zu wechseln. --- version: "current" language: "de" --- # Verwendung von Variablen in Testfällen ## Motivation Bei der Erstellung automatisierter Tests kann es notwendig werden, Werte für eingetragene Daten aus Variablen zu beziehen statt sie fest in den Test einzutragen. Außerdem kann es die Lesbarkeit erhöhen, wenn beim Umgang mit mehreren verknüpften Datensätzen etwa deren Kurzname über eine Variable referenziert statt überall dupliziert wird. ## Definition einer Variable Variablen müssen vor ihrer Verwendung im Test deklariert und definiert werden. Dies ist auf Ebene des Testfalls möglich. Die Syntax dazu lässt sich am einfachsten mit folgendem Beispiel erklären: class MyTestWithVariables extends BaseWebClientSpec { @Shared def myCustomerName = "Testkunde für meine Tests" @Shared def myActivityName = "Name meiner Testaktivität" // Hier folgen die Testschritte } Dabei ist die Angabe von `@Shared` erforderlich, damit der Wert der Variable in allen Testschritten ordnungsgemäß verfügbar ist. Die Angabe von `@Shared` kann wie im Beispiel gezeigt eine Zeile über der Variablendeklaration oder in der gleichen Zeile erfolgen. In diesem Beispiel sind in der Testklasse dadurch die Variablen `myCustomerName` mit dem Wert "Testkunde für meine Tests" und `myActivityName` mit dem Wert "Name meiner Testaktivität" verfügbar. ## Nutzung einer Variable Variablen können an allen Stellen im Test genutzt werden, wo normalerweise feste Zeichenketten erwartet werden. Beispiele dafür sind etwa erwartete Werte für Feldwertprüfungen oder Werte, die in Felder eingetragen werden sollen. Die Verwendung erfolgt dabei durch die Eingabe von `${variablenName}`-Platzhaltern innerhalb der Anführungszeichen der Zeichenkette. Dabei wird dann der Platzhalter durch den Wert der angegebenen Variable ersetzt. Auch eine Kombination aus festen Werten und Variablenplatzhaltern ist möglich, wie das nächste Beispiel zeigt. class MyTestWithVariables extends BaseWebClientSpec { @Shared def activityName = "Testaktivität" def "Demonstrate variable usage on Activity mask"() { given: open entity "Activity" create dataset set field "Subject.Activity" to "${activityName}" field "Subject.Activity" should be "Testaktivität" set field "Subject.Activity" to "Meine ${activityName}" field "Subject.Activity" should be "Meine Testaktivität" close level pick dialog option NO } } Bei der Verwendung von Variablen muss darauf geachtet werden, dass sie stets mit einem Kleinbuchstaben beginnen, wie in dem vorherigen Beispiel "activityName". Anwender mit Scripting-Erfahrung, etwa durch die Arbeit mit BPM-Scripting oder Maskenscripting fragen sich möglicherweise, ob die Variablen auch "direkt" im Test-Script verwendet werden können, statt immer über die String-Ersetzung verwendet werden zu müssen. Leider ist dies aufgrund der technischen Basis der Test-Studio "Programmiersprache" beziehungsweise Domain Specific Language (DSL) nicht zuverlässig möglich. In den meisten Fällen wird die Verwendung von Variablen außerhalb von Strings in Verbindung mit Test-Studio Keywords zu Fehlern beziehungsweise unerwartetem Verhalten führen und wird daher nicht unterstützt. ## Besondere Variablen ### Generierende Variablen #### generate unique identifier \>=24.3 Generiert einen eindeutigen Bezeichner, um diesen Variable anschließend in den Testschritten verwenden zu können. **Beispiel** @Shared def myIdentifier = generate unique identifier @Shared def myName = "myName $myIdentifier" #### generate unique IBAN \>=24.3 Generiert eine eindeutige IBAN. **Beispiel** @Shared def myIban = generate unique IBAN ### Datumsvariablen #### resolve current date \>=24.3 Ermittelt das aktuelle Datum des Systems. Dies kann zu einem Fehler führen, wenn die Variable um 11:59:50 ermittelt wird, der Testfall jedoch z. B. eine neue Aktivität um 12.01:10 erstellt und dann versucht das Erstelldatum der Aktivität mit der Variable zu vergleichen. Darüber hinaus wird das Datum des Systems ermittelt, wo das Test-Studio gestartet wurde. Wenn ein Server in einer anderen Zeitzone zum Testen genutzt wird, kann es ebenfalls zu Fehlern kommen. (Sehr unwahrscheinlich) Ab \>=25.1 gibt es weitere **Datumskonstanten** (Details siehe unten). **Beispiel** @Shared def currentDate = resolve current date #### resolve "dateConstant" adding "relativeDate" \>=25.1 Ermöglicht die Verwendung von dynamischen Datumsangaben. Fährt man mit der Maus im Editor über das Datumskonstrukt, wird der daraus berechnete Datumswert angezeigt. **Beispiel** @Shared def myDATE = resolve "08.02.2024" adding "4d" set field "TestDate.TestEntity" to "${myDATE}" field "TestDate.TestEntity" should be "12.02.2024" #### Datumskonstanten Möglichkeit zur dynamischen Abbildung von häufig genutzten Datumswerten in Abhängigkeit zum Systemdatum, wie beispielsweise dem ersten Tag eines aktuellen Monats. Sie werden mit dem Keyword "resolve" eingeleitet. Folgende Datumskonstanten sind ab 25.1 verfügbar: * `first of current month` * `last of current month` * `first of next month` * `last of next month` * `first of current year` * `last of current year` * `first of next year` * `last of next year` **Beispiel** @Shared def fiCuMo = resolve first of current month --- version: "current" language: "de" --- # BPM ![BPM.svg](https://help.cursor.de/__attachments/a_0dce1b0492555e2f5bab496ce31c38c60acad6a233a323ed27774e89b49b4e7b/BPM.svg?cb=8397d52e2d2070e62e41267885be3665) [![BPMWeb.svg](https://help.cursor.de/__attachments/a_d656ba29020019f22f06c203bbdcf9eef2e4d534107f93976c856dbe5a873d7a/BPMWeb.svg?cb=cdc0b1bff09a6e8c10839b71588bc242)](/de/bpm/current/bpm-im-web.md) [**BPM im Web**](https://help.cursor.de/de/bpm/current/bpm-im-web.md) Ab 2026.1 LTS [![BPMAlt.svg](https://help.cursor.de/__attachments/a_071b422bb1c019b4ea98047f54a7af302d59e9c1bb70689e9279ac3b5c01c5d0/BPMAlt.svg?cb=a57553ea6dbecf1e9b0db1894b865e36)](/de/bpm/current/bpm-alt.md) [**BPM (alt)**](https://help.cursor.de/de/bpm/current/bpm-alt.md) BIS 2025.6 --- version: "current" language: "de" --- # Aktionen In CURSOR-BPM stehen im Wesentlichen drei Aktionstypen zur Verfügung, die sich in Interaktivität, Performance und Einsatzgebiet unterscheiden. ## Benutzer-Aktionen ![UserTask.svg](https://help.cursor.de/__attachments/a_21d575793318a0749028f00bc48b36691c8008c41f6a017eacd0bf78c0bbfed0/UserTask.svg?cb=c321707cdf3deb7eedbfc6773817dc91) **Beschreibung** Benutzer-Aktionen binden Anwender direkt in den Prozess ein. Es wird eine Aufgabe erzeugt, typischerweise mit Maske, Eingabefeldern und ggf. Validierung. **Vorteile** * Hohe fachliche Nachvollziehbarkeit („Wer entscheidet was, wann?") * Geeignet für Genehmigungen, Prüfungen, manuelle Entscheidungen * Unterstützt Eskalation, Zuweisung an Rollen und UI-Logik (Masken, Pflichtfelder) **Nachteile** * Prozess ist von Reaktionszeiten der Anwender abhängig * Nicht geeignet für sehr große Datenmengen oder rein technische Massenjobs * Längere Durchlaufzeiten (Wartezeiten auf Benutzeraktionen) **Typische Anwendungsfälle** * Freigabe eines Angebots oder Vertrags * Manuelle Qualitätsprüfung vor Versand (z. B. finale Sichtung eines Serienbrief-Layouts) * Nachbearbeitung einzelner Datensätze mit komplexen Masken ## Skript-Aktionen ![ScriptTask.svg](https://help.cursor.de/__attachments/a_e3b3a24b54f1049d9eea8ea50b9a6bdae174195a8f77b10209273a8357c6df21/ScriptTask.svg?cb=05e7cc8f0f8d23a08210ac7e53b25ff2) **Beschreibung** Skript-Aktionen führen Groovy-Skripte direkt in der Prozess-Engine aus. Sie automatisieren Logik im Kontext der aktuellen Prozessinstanz. **Vorteile** * Flexible Automatisierung fachlicher und technischer Logik * Gut geeignet für Einzel-Datensätze oder kleinere Datenmengen * Direkter Zugriff auf Prozessvariablen und das Datenmodell **Nachteile** * Läuft im Kontext der laufenden Prozessinstanz * Nicht ideal für sehr große Datenmengen (lange Laufzeiten, Transaktionslast) * Fehler im Skript betreffen direkt die aktuelle Prozessinstanz **Typische Anwendungsfälle** * Berechnung und Setzen von Status- oder Feldwerten (z. B. Score, nächste Fälligkeit) * Erzeugen einzelner Aktivitäten oder Dokumente aus Prozesskontext * Prüfung von Vorbedingungen, Routing-Entscheidungen (z. B. „welcher Teilprozess?") ## Massendaten-Aktionen ![MassDataTask.svg](https://help.cursor.de/__attachments/a_04b961afb4858c54fe4f2291f64c67278ebc80b550850bdd1868c1f1d2059b90/MassDataTask.svg?cb=a38d9720bdfafd1ba3686d525751bb0e) **Beschreibung** Massendaten-Aktionen sind für die Verarbeitung großer Datenmengen ausgelegt. Sie unterbrechen den BPM-Prozess, starten einen Hintergrundjob auf dem Massendatenserver und setzen den Prozess nach Abschluss fort. **Vorteile** * Hohe Performance und Skalierbarkeit bei Massendaten * Robust gegenüber Serverneustarts (Abarbeitung in Auftragswarteschlange) * Verarbeitung pro Datensatz in eigener Transaktion (teilweise Rollback möglich) * Spezialisierte Typen: allgemeine Massendatenverarbeitung, Serienbrief, Serienmail, Excelvorlage **Nachteile** * Komplexere Konfiguration (Suchdefinition, Variablen, Logging) * Läuft außerhalb der Prozess-Engine: Prozessvariablen sind nur lesend verfügbar * Ergebnis nur aggregiert oder über Protokolle (Massendatenaktion / -protokoll) einsehbar **Typische Anwendungsfälle** * Massenaktualisierung von Datensätzen (z. B. Kennzeichen, Preise, Zustände) * Serienbriefe und Serienmails an große Empfängergruppen * Generierung von Excel-Auswertungen auf Basis umfangreicher Suchergebnisse * Batch-artige Hintergrundjobs, die unabhängig von Benutzerinteraktion laufen sollen **Zusammengefasst** * **Benutzer-Aktion**: für interaktive, manuelle Schritte (Entscheiden, Prüfen, Freigeben) * **Skript-Aktion**: für automatisierte Logik im Prozesskontext bei normalem Datenvolumen * **Massendaten-Aktion**: für große Datenmengen und batchartige Verarbeitung im Hintergrund Die Wahl des Aktionstyps sollte sich immer an **Datenmenge** , **Interaktionsbedarf** und **Performanceanforderungen** orientieren. --- version: "current" language: "de" --- # Aktionsbox Ein Prozess wird aus der Aktionsbox gestartet. Er enthält alle selektierten Datensätze aus der Listenansicht, die im Prozess verarbeitet werden können (aber nicht müssen). ![grafik-20260209-182216.png](https://help.cursor.de/__attachments/a_9547ca27a5a4458850fd219b41a1dfc0d61dba18da1a8d7bdb521b8c388e8d5f/grafik-20260209-182216.png?cb=7a978040ff83493c6f09a1bddfba961f) *Beispiel-Aktionen bei Leads* **Permanente Parameter** * eventName: `ACTION_BOX` * ProcessID: Id des gestarten Prozesses * entityName: Der Name der Entität (optional) * containers: Die Liste der selektierten Datensätze vom Typ `IContainer` **Initial verfügbare Parameter** * workSpace: Der aktuelle Datenbereich (Datentyp: `IScriptWorkSpace`) Wenn im Start-Ereignis auf eine Entität eingeschränkt wurde, so kann der Prozess nur in der Aktionsbox zur jeweiligen Entität ausgewählt werden. Ist die Auswahl leer, so kann der Prozess aus jeder beliebigen Entität gestartet werden. Der Administrator hat dafür Sorge zu tragen, dass er im Prozess auf verschiedenen Entitäten reagiert. Wenn ein Prozess zwingend einen ausgewählten Datensatz voraussetzt, sollte dieser per Skripting in der Aktionsbox deaktiviert sein, solange kein Datensatz ausgewählt wurde. --- version: "current" language: "de" --- # (alt) Änderungshistorie Die Änderungshistorie enthält alle Änderungen am aktuellen Prozess. Jedes Speichern, Veröffentlichen, die Anlage oder das Importieren, sind Hauptänderungen, die in der oberen Tabelle nach Datum absteigend sortiert angezeigt werden. Die Tabelle lädt in der Standard-Konfiguration die letzten 100 Änderungen. Über den Schalter 'Alle Änderungs-Einträge laden' können alle Änderungen angezeigt werden. ![Änderungshistorie.png](https://help.cursor.de/__attachments/a_875f95a0fe08501c7f5e5b36f1a4bfbbd2e1369fda31ec7447620df413cabe0c/%C3%84nderungshistorie.png?cb=6471907f2646773c657541bc23d69d9e) Zu gespeicherten Änderungen in den Modellen gibt es Detail-Informationen, die bei der Selektion einer Hauptänderung in der unteren Tabelle angezeigt werden. Die Detailänderungen enthalten den Namen der Aktion sowie den Namen der geänderten Eigenschaft. Änderungen im Skript oder in der Konfiguration einer Aktion werden **nicht**im Einzelnen festgehalten. Vgl. Änderungshistorie im Maskenskript. Alte Einträge können je nach Selektion oder Anlagedatum entfernt werden. Dadurch werden sie auch aus der Prozess-Übersicht und im Cockpit entfernt. --- version: "current" language: "de" --- # Änderungshistorie und übergeordnete Prozesse ## Grundlagen In den Prozessdetails im Tab **Übersicht** finden sich: * die Änderungshistorie des Prozesses * die Fehlerprotokolle (siehe hierfür auch [Logging und Fehleranalyse](https://help.cursor.de/de/bpm/current/logging-und-fehleranalyse.md) ) * sowie -- sofern es sich um einen Teilprozess handelt -- die Auflistung der übergeordneten Prozesse ![docu-evi.dev.cursor.de_webclient_cursor_desktop_index.jsf(Full HD) (6)-20260209-111555.png](https://help.cursor.de/__attachments/a_afd3278dd4da5a16b7b67be171fd89d9388e1c2845ec495717656dba52b3df1e/docu-evi.dev.cursor.de_webclient_cursor_desktop_index.jsf(Full%20HD)%20(6)-20260209-111555.png?cb=207586f6e29ed4f00a5c0e6b849a4c6f) *Detailansicht eines Teilprozesses* ## Änderungshistorie In der Änderungshistorie werden alle Hauptänderungen am Prozess protokolliert: * Speichern * Veröffentlichen * Anlage eines neuen Prozesses * Import eines Prozesses Diese Einträge werden absteigend nach Datum und Uhrzeit angezeigt. Für jede Änderung ist ersichtlich, welcher Benutzer diese wann genau durchgeführt hat. Über die Buttons oben rechts in der Karte „Änderungshistorie" können Einträge gelöscht werden, die älter als drei Monate oder ein Jahr sind. ## Übergeordnete Prozesse Handelt es sich bei dem betrachteten Prozess um einen Teilprozess, werden im Tab **Übersicht** außerdem die übergeordneten Prozesse aufgelistet, in denen dieser Teilprozess verwendet wird. Diese übergeordneten Prozesse können über das Link-Icon direkt geöffnet werden, um deren Aufbau und Verwendung des Teilprozesses nachzuvollziehen. --- version: "current" language: "de" --- # Arbeiten mit Standardprozessen Standardprozesse stehen im Core des CRM-Systems sowie modulabhängig zur Verfügung. Das bedeutet, dass fachlich zu einem Modul gehörende Prozesse gemeinsam mit dem jeweiligen Modul ausgeliefert werden. Diese Standardprozesse bilden die Grundlage für viele zentrale Abläufe im System. Sie können nicht gelöscht, sondern lediglich deaktiviert werden. Standardprozesse sind eindeutig erkennbar: * am „C0"-Batch am Prozess-Icon * an der Prozess-ID, die mit „C0" beginnt * an der Schicht, die -- solange der Prozess nicht übersteuert wurde -- ebenfalls „C0" ist. Mit dem Update auf eine neue Releaseversion des CRM-Systems werden neue Standardprozesses sowie Änderungen an bestehenden Standardprozessen automatisch in das System eingespielt. Bei Bedarf können Standardprozesse übersteuert und individualisiert werden (siehe Kapitel *Erstellung und Änderung von Prozessen*). Durch die Übersteuerung wird eine Kopie des Standardprozesses in die Kundenschicht übernommen und dort angepasst. Dies hat zur Folge, dass Neuerungen und Anpassungen, die CURSOR zukünftig am ursprünglichen Standardprozess vornimmt, nicht mehr automatisch in den übersteuerten Prozess einfließen. Der individuelle Prozess in der Kundenschicht bleibt in diesem Fall führend. Die ursprüngliche Standardkonfiguration sowie der Standardprozess bleiben jedoch weiterhin jederzeit einsehbar. Wird ein Standardprozess (C0) übersteuert, bleibt der ursprüngliche C0-Prozess aktiv, solange die Übersteuerung nicht veröffentlicht wurde. Erst mit der Veröffentlichung des übersteuerten Prozesses wird der individuelle Prozess führend. Im Standard ist es üblich, Logiken in die Skriptbibliothek auszulagern. Dadurch können an vielen Stellen gezielte Anpassungen vorgenommen werden, ohne dass für jede kleinere Änderung der gesamte Prozess übersteuert werden muss. Gleiches gilt für die Auslagerung von Prozessschritten in Teilprozesse. Solche Teilprozesse können bei Bedarf unabhängig vom Hauptprozess übersteuert werden, was eine noch feinere und wartungsärmere Individualisierung ermöglicht. --- version: "current" language: "de" --- # Auswahl Für einfache Meldungen, Entscheidungen oder Auswahl kann dem Anwender eine einfach konfigurierbare Maske als Task-Aktion präsentiert werden. Allen gemein ist ein Meldungs-Symbol sowie der internationalisierbare Meldungs-Text. Die Möglichkeiten sind wie folgt: * Meldung * Auswahl Ja/Nein * Auswahl Liste * Auswahl Schalter Das Icon des Dialogs kann statisch gewählt werden. Zur Übersteuerung des Icons ist es möglich eine Variable vom Typ Integer zu hinterlegen. Wenn diese einen Werte aus den Konstanten `GUIConstants.INFO_MESSAGE`, `GUIConstants.QUESTION_MESSAGE`, `GUIConstants.WARNING_MESSAGE` oder `GUIConstants.ERROR_MESSAGE` enthält, wird das übersteuerte Icon angezeigt. Der Meldungstext ist an die in CURSOR-BPM eingestellt Sprache gebunden und wird so in der Prozess-Definition abgelegt. Um den statischen Meldungstext durch dynamische Werte aus dem Prozess anzureichern, können Prozessvariablen mit der Schreibweise `${variablenname}` angegeben werden. Es gilt zu beachten, dass die Nachricht als HTML-Text abgelegt wird. Daher sind Zeilenumbrüche in Text-Variablen mit "*\*" anzugeben. Aktuell stehen keine Konvertierungsmethoden für z.B. Zahlenwerte zur Verfügung. Einige Werte werden daher vor der Ersetzung konvertiert: * Nachschlagewerte: Hier wird der Schlüsselwert dargestellt * Zahlenwerte: Diese werden nach der Sprache des Clients konvertiert * Datumswerte: Diese werden sprachspezifisch im Format *dd.MM.JJJJ hh:mm* ausgegeben Für die Auswahldialoge kann der Abbrechen-Schalter nicht eingeblendet werden. Es muss zwangsläufig eine Option gewählt werden. Jede Auswahl muss für die spätere Auswertung in eine Prozess-Variable geschrieben werden. Die Variable muss in der Prozess-Sammlung angelegt werden, damit es in der Konfiguration zur Auswahl steht. Für die verschiedenen Auswahlarten, müssen weitere Einstellungen getroffen werden. * **Auswahl Ja/Nein** Variable für Rückgabewert - Hier steht die ID `BUTTON_YES` oder `BUTTON_NO` * **Auswahl Liste** Variable für Auswahlliste - Eine Liste mit Werten (vorzugsweise Literal-Werte) zur Auswahl Variable für Rückgabewert - Der Index des gewählten Eintrags aus der Liste beginnend bei 0. * **Auswahl Schalter** Variable für Rückgabewert - Hier steht die interne ID des geklickten Schalters zur Verfügung Schalterkonfiguration - Für die Anzeige können beliebig viele Schalter mit eindeutiger ID und Anzeigename hinzugefügt werden. Über das Kontextmenü können einzelne Schalter wieder entfernt oder geändert werden. Auch für die Beschriftung des Schalters können Prozess-Variablen mit der Schreibweise `${variablenname}` verwendet werden. --- version: "current" language: "de" --- # (alt) Auswahl-Dialoge Für einfache Meldungen, Entscheidungen oder Auswahl kann dem Anwender eine einfach konfigurierbare Maske als Task-Aktion präsentiert werden. Allen gemein ist ein Meldungs-Symbol sowie der internationalisierbare Meldungs-Text. Die Möglichkeiten sind hier: * Meldung * Auswahl Ja/Nein * Auswahl Liste * Auswahl Schalter ![CRM-12065_config.png](https://help.cursor.de/__attachments/a_20dffc12b918d4d5562760b47a5b7078205b6983622553d73da17b4597fab560/CRM-12065_config.png?cb=ccf498c995417a302f28ef4e375248f4) Das Icon des Dialogs kann statisch gewählt werden. Zur Übersteuerung des Icons ist es möglich eine Variable vom Typ Integer zu hinterlegen. Wenn diese einen Werte aus den Konstanten `GUIConstants.INFO_MESSAGE`, `GUIConstants.QUESTION_MESSAGE`, `GUIConstants.WARNING_MESSAGE` oder `GUIConstants.ERROR_MESSAGE` enthält, wird das übersteuerte Icon angezeigt. Der Meldungstext ist an die in CURSOR-BPM eingestellt Sprache gebunden und wird so in der Prozess-Definition abgelegt. Um den statischen Meldungstext durch dynamische Werte aus dem Prozess anzureichern, können Prozessvariablen mit der Schreibweise `${variablenname}` angegeben werden. Es gilt zu beachten, dass die Nachricht als HTML-Text abgelegt wird. Daher sind Zeilenumbrüche in Text-Variablen mit "*\*" anzugeben. Aktuell stehen keine Konvertierungsmethoden für z.B. Zahlenwerte zur Verfügung. Einige Werte werden daher vor der Ersetzung konvertiert: * Nachschlagewerte: Hier wird der Schlüsselwert dargestellt * Zahlenwerte: Diese werden nach der Sprache des Clients konvertiert * Datumswerte: Diese werden sprachspezifisch im Format *dd.MM.JJJJ hh:mm* ausgegeben Für die Auswahldialoge kann der Abbrechen-Schalter nicht eingeblendet werden. Es muss zwangsläufig eine Option gewählt werden. Jede Auswahl muss für die spätere Auswertung in eine Prozess-Variable geschrieben werden. Die Variable muss in der Prozess-Sammlung angelegt werden, damit es in der Konfiguration zur Auswahl steht. Für die verschiedenen Auswahlarten, müssen weitere Einstellungen getroffen werden. * **Auswahl Ja/Nein** Variable für Rückgabewert - Hier steht die ID `BUTTON_YES` oder `BUTTON_NO` * **Auswahl Liste** Variable für Auswahlliste - Eine Liste mit Werten (vorzugsweise Literal-Werte) zur Auswahl Variable für Rückgabewert - Der Index des gewählten Eintrags aus der Liste beginnend bei 0. * **Auswahl Schalter** Variable für Rückgabewert - Hier steht die interne ID des geklickten Schalters zur Verfügung Schalterkonfiguration - Für die Anzeige können beliebig viele Schalter mit eindeutiger ID und Anzeigename hinzugefügt werden. Über das Kontextmenü können einzelne Schalter wieder entfernt oder geändert werden. Auch für die Beschriftung des Schalters können Prozess-Variablen mit der Schreibweise `${variablenname}` verwendet werden. ![CRM-12065_view.png](https://help.cursor.de/__attachments/a_6c4cc50da2381b2c159744b43b1363d761acc8b104dcea5636ddfcfdb4193253/CRM-12065_view.png?cb=4a7f69acc6b0ea2b202cefb9945c5e44) --- version: "current" language: "de" --- # (alt) Benutzer-Aktion ## Benutzer-Aktion ![bpm.palette.48x48.UserTask.png](https://help.cursor.de/__attachments/a_66f3cd60d6f1d9a7d2095a3cfcdd6130e6a2ed5dbb19cb0fb4cd7ce0a7edb5af/bpm.palette.48x48.UserTask.png?cb=4ea22fa8a0ea02424d3e9493866f2f3a) In einer Benutzer-Aktion werden Masken konfiguriert, die dem Anwender eine definierte Interaktion ermöglichen. Jede Benutzer-Aktion wird einem oder mehreren Benutzern oder Gruppen zugeordnet, die diese Aktion bearbeiten können. Es stehen unterschiedliche Masken zur Verfügung: * Detailmaske (zur Dateneingabe) * Selektionsmaske (zur Datenauswahl) * Meldung (zur Information) * Auswahl (zur Auswahl mit unterschiedlichen Optionen) * Dokument bearbeiten (zum Bearbeiten eines Dokuments) Zu jeder Benutzer-Aktion sollten Sie eine sprechende Bezeichnung und eine ausführliche Dokumentation hinterlegen. Denn diese Informationen werden dem Prozess-Anwender in seiner Task-Liste angezeigt. Zudem kann sich der Anwender per Tooltip in der geöffneten Aktions-Maske diese Informationen anzeigen lassen. ### Zuständigkeiten pflegen Jeder Aktion muss ein oder mehrere Benutzer und/oder Benutzer-Gruppen zugewiesen werden. Die Auswahl erfolgt durch Zuordnen von Mitarbeitern und Gruppen. Initial werden Ihnen die speziellen Benutzer, der aktuelle Benutzer und der Start-Benutzer sowie die Haupt-Benutzergruppe des aktuellen Benutzers angezeigt. Für die Auswahl weiterer Benutzer oder Gruppen können Sie durch eine Eingabe im Suchfeld nach diesen suchen. Die Benutzergruppen sind die Rechte-Gruppen des CRM-Systems. Sobald eine Gruppe oder mehrere Benutzer einer Aktion zugewiesen sind, wird diese als Gruppen-Aktion in der Aktions-Liste dargestellt. Durch hintereinander geschaltete Benutzer-Aktionen können Sie für den Anwender eine Anwenderführung im Sinne einer Wizardsteuerung realisieren. Dafür gibt es die speziellen Templates aktueller Benutzer und Start-Benutzer. ![screenshot.4.png](https://help.cursor.de/__attachments/a_4050e2a6ad3946ed7b1c1a6676282a9ac5a2bc1df3ae3a97f4863e2b837d7404/screenshot.4.png?cb=0748b1877a3c8ef5f672d6c97af091cd) Anstatt einer festen Benutzerzuordnung können Variablen aus dem Prozesskontext zugewiesen werden. Der Zuordnungsdialog zeigt alles in der Bibliothek angelegten Variablen an. ![screenshot.5.png](https://help.cursor.de/__attachments/a_2ffb059af7326573419ff5fda98f897eb908eba0ae253570bc22b459b6cb6c86/screenshot.5.png?cb=28887cff6d89be4b2a12e629dfe56aba) Für die Zuordnung muss bestimmt werden, ob die Variable den Primärschlüssel eines Mitarbeiters oder einer Gruppe enthält. Der Primärschlüssel darf dabei nicht null oder leer sein. Variablen und feste Zuordnungen dürfen gemischt werden. ### Synchronisation von Daten CRM-Daten im Prozess können beim Öffnen der Benutzeraktion automatisch aktualisiert werden. ![screenshot.6.png](https://help.cursor.de/__attachments/a_bda5d5dcabc3e132a1d018d699f9457b644e9b8a813fb4a3fe067b7ba78e2c74/screenshot.6.png?cb=6ad7b8e600e48f1bd7a92826123d5285) Die Aktualisierung bezieht sich auf alle im Prozess verwendeten Variablen vom Typ IContainer mit der Option 'automatisch synchronisieren' ![screenshot.31.png](https://help.cursor.de/__attachments/a_23e6956e09b3833af650ed85220285b4cbb66895ce26850dfdd1e12645784645/screenshot.31.png?cb=3a2a19d64fcfc4378e883062a8a0d56d) Besonderheit für die CRM-Detailmaske: Die Aktualisierung findet mit dem Klick auf den Weiter-Schalter statt, so werden Änderungen, die zwischendurch am Datensatz gespeichert wurden, direkt dem Prozess wieder mitgegeben. **Tipp** Besonderheit für die CRM-Detailmaske: Die Aktualisierung findet mit dem Klick auf den Weiter-Schalter statt, so werden Änderungen, die zwischendurch am Datensatz gespeichert wurden, direkt dem Prozess wieder mitgegeben. Werden Felder des Datensatzes in der Prozessmaske geändert und sollen auch direkt im CRM-System aktualisiert werden, ist die Option 'Automatisch speichern' zu wählen. Die Feldwerte müssen im Skript der Benutzeraktion aber aus der IContainer-Variable ausgelesen bzw. wieder dorthin zurückgeschrieben werden. ### Benutzer-Aktion konfigurieren Es stehen unterschiedliche Benutzer-Aktionen zur Verfügung. Zur Konfiguration ist der entsprechende Aktionstyp auszuwählen. Diese werden im Folgenden erläutert: * **Aktionstyp Detailmaske** Eine Detailmaske dient dem Anwender zur Eingabe von Daten in einer Detailmaske (analog zum CRM). Eine Detailmaske besteht aus einer GUI, welche Sie über den GUI-Builder erstellen und bearbeiten können. Es handelt sich hierbei um sogenannte Prozessmasken, die analog zu den Masken im CRM sind. Eine Prozessmaske kann in mehreren Prozessen verwendet werden. Bitte beachten Sie: ändern Sie eine Prozessmaske in einem Prozess, so wirkt sich dies auch auf alle weiteren Prozesse aus, in denen dieselbe Maske Verwendung findet. Bei Bedarf legen Sie einfach eine neue Maske an, falls Sie die Änderungen nicht in den anderen Prozessen nutzen möchten. Die Eigenschaften der Felder werden (zur Laufzeit) aus den normalen CRM-Masken übernommen. Dies gilt auch für Feldrechte, so dass ein schreibgeschütztes Feld auch in BPM-Masken schreibgeschützt ist. * **Aktionstyp Selektion** Dieser Aktionstyp dient der Datensatzauswahl durch den Anwender. Per Konfiguration wird eine Suche hinterlegt, deren Anzeigefelder dem Anwender angezeigt werden. Suchen können Sie analog zu Prozessmasken in unterschiedlichen Prozessen verwenden, wobei sich Änderungen dann auf alle Prozesse auswirken. Es besteht die Möglichkeit, eine Suche anzulegen und zu bearbeiten oder eine vorhandene Suche aus dem CRM in den Prozess zu übernehmen. Aus den im Prozess vorhandenen Suchen kann dann eine Suche ausgewählt werden. Der Prozessdesigner kann zudem über Ergebnis-Selektion und Anzahl festlegen, wie viele Datensätze der Anwender auswählen kann oder darf. Mit der Option **Suche direkt ausführen** wird eingestellt, ob die Suche direkt ausgeführt wird, wenn der Anwender die Maske betritt oder ob der Anwender explizit "**Suchen** " betätigen muss. Sofern Sie dem Prozessanwender eine vorgefertigte Auswahl präsentieren möchten, können Sie mit der Option **Suchfelder anzeigen** die Möglichkeit der Sucheingabe durch den Anwender auch komplett unterbinden. * **Aktionstyp Meldung** Dieser Aktionstyp zeigt dem Anwender eine Meldung an. Die Meldung kann internationalisiert werden. Variablen lassen sich mit der Schreibweise `${variable}` im Text ausgeben. Das Meldungsfenster kann über den OK-Schalter geschlossen werden. * **Aktionstyp Auswahl Ja/Nein** Der Anwender soll eine Anfrage bestätigen oder verneinen. Durch das Drücken der Schalter wird das Meldungsfenster geschlossen. Die ID des Schalters (`BUTTON_YES`, `BUTTON_NO`) wird in die Ergebnisvariable geschrieben. * **Aktionstype Auswahl Liste** Stehen mehrere Daten zur Auswahl, so muss sich der Anwender für einen Eintrag aus der Liste entscheiden und die Auswahl mit OK bestätigen. Der gewählte Index (beginnend bei 0) wird in die Ergebnisvariable geschrieben. * **Aktionstyp Auswahl Schalter** Für einige Entscheidungen reichen die Schalter Ja und Nein nicht aus. Durch diesen Aktionstyp können Sie beliebig viele Schalter im Meldungsfenster anzeigen. Die ID des gewählten Schalters wird in die Ergebnisvariable geschrieben. * **Dokument bearbeiten** Wurde im Prozess ein Dokument serverseitig erzeugt, so kann es mittels des Primärschlüssels zur Bearbeitung geöffnet werden. Nach erfolgter Änderung kann das Dokument gespeichert und zurückgegeben werden. Wird das Aktionsfenster vorzeitig geschlossen, so werden die Änderungen am ausgeliehenen Dokument verworfen. ## Zwischenspeichern und Abbrechen In Benutzeraktionen vom Typ Detailmasken oder Selektion können eingegebene Feldwerte aus der Maske zwischengespeichert werden. Dies betrifft auch die im Skript gesetzten Variablen. Beim Öffnen einer Benutzeraktion mit zwischengespeicherten Daten gibt es folgenden Ablauf: 1. initTask() 2. Wiederherstellung aller Feldwerte und Variablen aus dem Zwischenspeicher 3. resumeTask() Als separate Option kann auf der Benutzeraktion **Prozessabbruch ermöglichen** aktiviert werden. ![screenshot.36.png](https://help.cursor.de/__attachments/a_7f824f259bfb7ae18ee76c208d94efa1f47deb0ee9606298ab59c6d6a5122821/screenshot.36.png?cb=216e9d739593b9408df9e9be4ffd38e7) Die laufende Prozessinstanz wird dadurch beendet. In den Auswertungen werden dieses Prozess-Instanzen mit dem Status **Gelöscht** geführt. ## Liste der offenen Aktionen in der Schnellstartleiste (im CRM) Die Liste der offenen Aktionen im CRM zeigt alle anstehenden, offenen Prozess-Schritte für den aktuellen Benutzer mit Erstellungsdatum, Name der Aktion und des Prozesses. Das Symbol unterscheidet Gruppen- und Benutzer-Aktionen. Beide Aktionstypen besitzen die gleiche Priorität. ![screenshot.38.png](https://help.cursor.de/__attachments/a_47e2cf04c6483c4b1e814276e117fa8f6879faf73919d8102c7e840a0658395a/screenshot.38.png?cb=5fd1ac105cf9e26b3425507702989ede) Jeder Aktion können Instanzinformationen als Details hinzugefügt werden. Diese sind in der Taskliste und im Kopf der Prozessmaske ersichtlich und ist nur für einzeilige Informationen optimiert. Auf Prozessvariablen kann über die Schreibweise `${variable}` zugegriffen werden. ![screenshot.42.png](https://help.cursor.de/__attachments/a_7e1ce15c99dda847bab56162a1ba2c95b89c02a123b5fba691f9b4508ee64e67/screenshot.42.png?cb=68e67f66ac879fa280319229c8c7f245) Gruppenaktionen müssen vor der Bearbeitung einem Benutzer zugewiesen werden. Dies geschieht durch den Anwender, wenn er den Task übernimmt. Hierdurch wird die Gruppenaktion zu einer Benutzeraktion und ist für andere Benutzer nicht mehr zugänglich. ![screenshot.39.png](https://help.cursor.de/__attachments/a_b82629839c7b23ba664890eb14ac4060b31cabe9a8df8430ae7d7ebbd23ebace/screenshot.39.png?cb=24fc051175ab0870722a8c58132433b5) Über den Schalter **Öffnen** wird die Aktions-Maske schreibgeschützt angezeigt. Mit **Bearbeiten** wird die offene Aktionen dem aktuellen Benutzer zugewiesen und zur Bearbeitung geöffnet. Benutzer-Tasks können nur zur Bearbeitung geöffnet werden. ![screenshot.40.png](https://help.cursor.de/__attachments/a_1a44d3bb1c99c91175d65715c1aa603f66364956e0da6846b77ac0487d5190a6/screenshot.40.png?cb=b13d1d0bae8560461af173dc700f5e0f) Die ausführliche Beschreibung der Aktion kann als Tooltip über dem Icon eingesehen werden. Hier wird dem Anwender die vom Prozessdesigner hinterlegte Dokumentation dieses Prozessschrittes angezeigt. Neue Einträge in der Liste der offenen Aktionen werden in der Schnellstartleiste durch eine rote Markierung mit entsprechender Anzahl signalisiert. ![screenshot.41.png](https://help.cursor.de/__attachments/a_24b6572e83ba6a905cb40c20592cdbad519f9fae850990b6a008a91bb668794e/screenshot.41.png?cb=52d8b7764177be8d6ac4cf318d942b01) Zudem haben Sie die Möglichkeit, neue Einträge durch ein Benachrichtigungsfenster am rechten unteren Rand der Anwendung anzeigen zu lassen, sofern die Benutzereinstellung **Allgemein/Aktiviere Benachrichtigungsfenster** aktiviert ist. --- version: "current" language: "de" --- # Benutzer-Aktionen ![UserTask.svg](https://help.cursor.de/__attachments/a_07af6e56cf95abbcabf7552de9e9d4e9a4803cc7b8eb2f1504b40454b74ec04b/UserTask.svg?cb=c321707cdf3deb7eedbfc6773817dc91) Es stehen unterschiedliche Benutzer-Aktionen zur Interaktion eines Anwenders innerhalb eines geführten Geschäftsprozesses im CRM zur Verfügung. Hier ist eine kurze Übersicht der verfügbaren Aktionen: | **Aktionstyp** | **Verwendung** | |--------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Auswahl Ja / Nein Auswahl Liste Auswahl Schalter | Einfache Entscheidungen oder Auswahl im Rahmen von Prozess-Abzweigungen oder dynamischen Variablen im nächsten Prozessschritt *z.B. Ja / Nein-Frage: "Soll ein neuer Ansprechpartner angelegt werden?" anhand deren Antwort der nächste Schritt zur Neuanlage eines Ansprechpartners durchgeführt oder übersprungen werden kann* | | CRM-Detailmaske | Nutzung von Bereichs-(Entitäts-)Masken zur Ergänzung oder Bearbeitung von Informationen zu einem Datensatz *z.B. Ansprechpartner-Maske* | | Detailmaske | Speziell für den BPM-Prozess konfigurierte Maske zur Eingabe von Informationen, die über mehrere Bereiche / Entitäten verteilt sein oder im Prozess weiterverarbeitet werden können | | Dokument bearbeiten | Öffnet und bearbeitet ein bestehendes Dokument zum zugehörigen CRM-Datensatz (z.B. Angebot, Vertrag) | | Dokumente hinzufügen | Fügt einem Datensatz eines oder mehrere neue Dokumente hinzu | | Maildialog | Versand einer E-Mail, bei der optional Informationen (z. B. Status, Anhänge, Aktivitäten) zurück in das CRM/den Prozess synchronisiert werden können | | Meldung | Zeigt dem Benutzer eine Meldung/Hinweis im Prozess an (z. B. Bestätigungen, Warnungen) | | Neuanlage | Ermöglicht die Neuanlage eines Datensatzes (z. B. neuen Kunden, Vorgang, Ticket) als Teil eines Prozesses | | Selektion | Identifikation von Datensätzen mithilfe einer Suche, die im weiteren Verlauf des Prozesses verwendet werden *z.B. die Auswahl von Ansprechpartnern, die mit einer Aktivität verknüpft werden sollen* | Benutzeraktionen dürfen ++nicht++ im Anschluss an Vorher-Ereignissen eingefügt werden, da dort die Transaktion abgeschlossen und der Datensatz gespeichert wurde. Die Veröffentlichung von Prozessen, die ein solches Prozessdesign verwenden, wird durch die Validierungslogik verhindert. Stattdessen können Benutzeraktionen im Zusammenspiel mit Nachher-Ereignissen eingefügt werden. --- version: "current" language: "de" --- # Benutzer-Start (Hauptnavigation) Der Prozess wird aus der Hauptnavigation unter dem Menüpunkt **Prozesse** heraus gestartet. Er kann als Favorit in den Lesezeichen abgelegt werden. Neue Prozesse stehen erst nach der Client-Neuanmeldung zur Verfügung. ![grafik-20260209-182452.png](https://help.cursor.de/__attachments/a_6d424509befd2fb4b48a72755d2ee1deb28c1ec67e7fd49c0b541424bb56a233/grafik-20260209-182452.png?cb=231db24ae7bc7b23aaa9e13bfa600425) **Permanente Parameter** * eventName: `MYCRM` * ProcessID: Id des gestarteten Prozesses --- version: "current" language: "de" --- # (alt) Bibliothek ## Bibliothek ![bpm.icons.48x48.Repository.png](https://help.cursor.de/__attachments/a_767db379ee784db39c3e399669777de3a69d1f1400f4f7b1700519e53af7457b/bpm.icons.48x48.Repository.png?cb=187c8857f597e860061a68e69f27c150) In der Bibliothek werden externe Ressourcen wie Masken, Suchen und Variablen verwaltet. Diese Informationen sind für die technische Modellierung relevant. Die **Bibliothek** gibt einen Überblick über verwendete Masken, Suchen und Variablen im technischen Prozess und bietet die Möglichkeit, diese zu bearbeiten. Eine markierte Maske lässt sich z.B. über **Bearbeiten** im GUI-Builder öffnen und ändern. Analog kann die Suchbearbeitung für die markierte Suche über ![bpm.icons.16x16.SearchEdit.png](https://help.cursor.de/__attachments/a_1299393d4e2bbfadd804e1041d5a117a6697907647491bb4df45ccc412190465/bpm.icons.16x16.SearchEdit.png?cb=0ec53e21b93c9608547e2cf20eaf4d07) erfolgen. ![Bibliothek.png](https://help.cursor.de/__attachments/a_4c667c2fca283670fe47b051669100464295e6ab9ce2ad3a1eea5c22aece1298/Bibliothek.png?cb=123c02217ab91ff8763365dd5772fa35) ### Masken und Suchen Masken und Suchen können aus anderen Prozessen dem eigenen Prozess hinzugefügt werden. Eine Änderung dieser Masken bzw. Suchen prüft die Verwendung anderen Prozessen. Aufgrund der Prüfung kann die Bearbeitung abgebrochen werden. Wird eine Maske bzw. Suche bearbeitet und gespeichert, so werden alle relevanten Prozess mit der Änderung markiert, d.h. die geänderten Daten sind auch dort im Änderungs-Log sichtbar. Hinzugefügte Elemente können über das Kontextmenü wieder aus dem Prozess entfernt werden. ![BibliothekMaskeEntfernen.png](https://help.cursor.de/__attachments/a_9502a31b2849f05b1309d23598a2c9a938921cb4a7fd4e9ac6f2f85f51adae9a/BibliothekMaskeEntfernen.png?cb=2e8b058dcae2f6ffe66cdfd78bfb0f65) Suchen und Masken aus dem CURSOR Standard oder einem Partnermodul können unabhängig vom Prozess übersteuert werden. Zum Zeitpunkt des Veröffentlichens wird die Definition aus der höchsten Customizing-Schicht geladen. Durch das Entfernen einer übersteuerten Suche oder Maske man den Ursprungszustand im Prozess wiederherstellen. Zusätzlich kann man den Namen des ausgewählten Eintrags via Kontextmenü in die Zwischenablage kopieren, um diese anschließend komfortabel in BPM-Skripten einfügen zu können. ### Variablen ![bpm.icons.16x16.VariableProcess.png](https://help.cursor.de/__attachments/a_b5dcd3fa0b6135555065c5bbe53923d03d432f482c49568a128e2777c239409c/bpm.icons.16x16.VariableProcess.png?cb=94edaffa6ba622b83eefde40b2fced2e) Des Weiteren können Variablen für den Prozess definiert werden, die dann in Skripten komfortabel via Autovervollständigung zur Verfügung stehen. Mittels **Variablen hinzufügen** wird eine Variable angelegt. ![Variable.png](https://help.cursor.de/__attachments/a_fc583909955df2da7e45e1a125414b0348cda86e0dd68c70ecc0ac4798291096/Variable.png?cb=787a82e03c20de4030640b14dcea1d6a) Jede Variable verfügt neben dem Namen und der Beschreibung über den Datentyp. Variable vom Typ `Object` können überall verwendet werden. Der Datentyp schränkt teilweise die Verwendungsstellen ein, z.B. Primärschlüssel sind für die Auswahl von Datensätzen vorgeschrieben. In einem Skript kann dieser Variable dennoch der falsche Datentyp zugewiesen werden. Die Typsicherheit kann weder beim Kompilieren noch zur Laufzeit im BPM-Skript sichergestellt werden. `IContainer`-Variablen erlauben eine Synchronisierung der Daten zwischen Prozess und CRM-System. Der Verwendungstyp ist wichtig für die Definition von Ein- bzw. Ausgabevariablen in Teilprozessen. Der Standard ist *Prozessintern* . Falsch angelegte Variablen können über das Kontextmenü auf dem Baum-Knoten nachbearbeitet werden. Der Name einer Variable darf nur geändert werden, wenn die Variable noch nicht verwendet wird. Nicht weiter benötigte Variablen können über das Kontextmenü wieder entfernt werden. So können diese Variablen beispielsweise mittels Autovervollständigung in Skripttasks ausgewählt werden (Tastenkombination STRg + LEERTASTE ). ![SkriptAktion.png](https://help.cursor.de/__attachments/a_734efac98eddc3c88cd1ff8231e1ef26612f963d06cc4e20bfec21829682be85/SkriptAktion.png?cb=05fca4e1d161c8c697d84064b7fd6aa3) Auf diese Weise sind Prozessvariablen registriert. Etwaige Schreibfehler werden vermieden. Globale Variablen sind spezielle Variablen für die Verteilung von Customizing Paketen, die im CRM definiert (**Admin-Konsole/Customizing/Globale Variablen**) und die im Prozess genutzt werden. Sie können in Test-, Abnahme- und Produktivsystem verschieden sein. Somit lassen sich beispielsweise Einstellungen, die im Prozess verwendet werden, unterschiedlich für Produktiv- und Testsystem konfigurieren, ohne dass der Prozess angepasst werden muss. Globale Variablen stehen Ihnen erst nach entsprechender Systemkonfiguration zur Verfügung. Bitte wenden Sie sich an Ihren Consultant. Prozessvariablen kann in der Bibliothek nun explizit ein Datentyp zugewiesen werden. Das erhöht die Prozessqualität, da z. B. bei der Variablenzuordnung im Teilprozess die Typkompatibilität geprüft wird. Zudem ermöglicht die Verwendung eines Datentyps weitere Funktionalitäten, wie z. B. die automatische Datensynchronisierung für Variablen mit dem Typ `IContainer`. Variablen werden mit dem Datentyp `Object` vorbelegt. Der Datentyp einer Variable kann auch nachträglich geändert werden. Der Datentyp wird in der Autovervollständigung, in der Bibliothek und in den Auswahlboxen von Variablen angezeigt. Benutzeraktionen, die den Primärschlüssel benötigen, können nur noch Variablen vom Typ `PrimaryKey` aufnehmen. Bestehende Prozesse und Prozessvariablen können unverändert weiterverwendet werden. In einem Skript kann einer Variable dennoch ein unpassender falscher Datentyp zugewiesen werden. Denn die Typsicherheit kann weder technisch weder beim Kompilieren noch zur Laufzeit im groovy-Skript sichergestellt werden. Wenn Sie in der Bibliothek für eine Variable vom `Typ IContainer` die Eigenschaft "Automatisch synchronisieren" definiert haben, dann können Sie diese im technischen Modell in folgenden Elementen folgendermaßen nutzen: * Benutzer-Aktion, dort "Detailmaske": "Automatisch aktualisieren" (Default: aktiviert) und/oder "automatisch speichern" (Default: aktiviert). * Eingehendes Nachrichten-Zwischenereignis: "Automatisch aktualisieren" (Default: aktiviert) * Zeitliches Zwischenereignis: "Automatisch aktualisieren" (Default: aktiviert) --- version: "current" language: "de" --- # Bibliothek ## Grundlagen Die Bibliothek eines BPM-Prozesses dient der Verwaltung externer Ressourcen, die in Prozessen verwendet werden -- insbesondere: * Masken * Suchen * Variablen * Teilprozesse * Skriptklassen Diese Informationen sind für die technische Modellierung relevant und unterstützen eine einheitliche, wartbare Prozessgestaltung. Sie ist erreichbar über den entsprechenden Button in der Toolbar des BPM-Prozesses. ![image-20260209-115133.png](https://help.cursor.de/__attachments/a_9f0332284619389d85e0bcbdb09ebaa020463261affdf1a5cc88b3d3c515ec15/image-20260209-115133.png?cb=973f8ff766b9533d4b8ce074399026f4) *Button zum Öffnen der Bibliothek in der Toolbar* Die Bibliothek bietet einen Überblick über alle im Prozess verwendeten Masken, Suchen und Variablen und die Möglichkeit, diese direkt zu bearbeiten. Die jeweiligen Gruppierungen können bei Bedarf aus- und eingeklappt werden. ![image-20260209-112411.png](https://help.cursor.de/__attachments/a_e335051ad64801a562644d0ef6db18191b121a6f4b8a306fabb0f2c3f5c33105/image-20260209-112411.png?cb=1e5f2dc402c1883a23a03d8324f5f9b0) *Beispielhafte Bibliothek eines BPM-Prozess* ## Masken und Suchen Masken und Suchen können aus anderen Prozessen dem aktuellen Prozess hinzugefügt werden. Dadurch lassen sich vorhandene Oberflächen und Suchdefinitionen wiederverwenden. **Verwendung und Auswirkungen von Änderungen** * Bei einer Änderung von Masken oder Suchen wird geprüft, in welchen anderen Prozessen diese verwendet werden. * Abhängig vom Ergebnis dieser Prüfung kann die Bearbeitung ggf. abgebrochen werden, um unerwünschte Auswirkungen auf andere Prozesse zu vermeiden. * Wird eine Maske oder Suche erfolgreich bearbeitet und gespeichert, werden alle betroffenen Prozesse mit der Änderung markiert. * Die Änderung erscheint damit auch in deren Änderungs-Log. Hinzugefügte Masken oder Suchen können bei Bedarf über das Kontextmenü wieder aus dem Prozess entfernt werden. **Standard- und Partnermodul-Elemente** Suchen und Masken aus dem CURSOR-Standard oder aus einem Partnermodul können unabhängig vom Prozess übersteuert werden. Beim Veröffentlichen des Prozesses wird jeweils die Definition aus der höchsten Customizing-Schicht geladen. Wird eine übersteuerte Suche oder Maske entfernt, kann dadurch der Ursprungszustand im Prozess wiederhergestellt werden. Über die Bibliothek kann außerdem eine neue Suche angelegt werden. Beim Erstellen einer neuen Suche aus dieser Maske heraus kann als Start-Entität nur eine Entität genutzt werden, die im Datenmodell des Prozesses enthalten ist. Ist das Datenmodell leer, ist der Button zur Neuanlage einer Suche entsprechend inaktiv. Die in der Suche definierten Anzeigefelder werden den Anwendern später in der Ausführung angezeigt. Um eine bestehende Maske in eine Prozessmaske zu wandeln, kann die Maske im CRM mit dem Maskeneditor geöffnet und als Datei gespeichert werden. Diese Datei kann als neue Prozessmaske über den Maskeneditor geladen werden. Einschränkung hierbei ist das ggf. vorhandene Maskenskript, dies kann nicht 1:1 übertragen werden. ## Variablen In der Bibliothek lassen sich Prozessvariablen definieren, die: * im Prozess selbst * insbesondere in Skripten (mit Autovervollständigung) verwendet werden können. Über „Neu" wird eine neue Variable angelegt. **Eigenschaften von Variablen** Jede Variable verfügt mindestens über: * Name * Beschreibung * Datentyp * Verwendungstyp **Datentyp** Variablen werden initial mit dem Datentyp `Object` vorbelegt. Der Datentyp kann nachträglich geändert werden. Typische Datentypen: * `Object`: universell verwendbar, keine Einschränkung * `PrimaryKey`: speziell für Primärschlüssel, z. B. zur Auswahl von Datensätzen * `IContainer`: ermöglicht automatische Datensynchronisierung zwischen Prozess und CRM-System * weitere spezialisierte Typen je nach Einsatz Der Datentyp schränkt teilweise die Verwendungsstellen ein (z. B. erwarten bestimmte Benutzeraktionen zwingend eine Variable vom Typ `PrimaryKey`). Bestehende Prozesse und Prozessvariablen können unverändert weiterverwendet werden. In einem Skript kann einer Variable dennoch ein unpassender Datentyp zugewiesen werden. Die Typsicherheit kann weder beim Kompilieren noch zur Laufzeit im Groovy-Skript technisch erzwungen werden. Die Typangabe dient daher primär der Qualitätssicherung und besseren Unterstützung bei der Konfiguration. **Verwendungstyp** Der Verwendungstyp ist relevant u. a. für Ein- und Ausgabevariablen in Teilprozessen (z. B. Eingabeparameter, Ausgabeparameter, Ein-/Ausgabeparameter). Der Standard-Verwendungstyp ist „Prozessintern". **Pflege und Korrektur** Variablen können über den Dreipunkte-Button in der Bibliothek nachbearbeitet werden. Der Name einer Variable kann nur geändert werden, wenn sie noch nicht verwendet wird. Nicht mehr benötigte Variablen können über den Dreipunkte-Button entfernt werden. **Verwendung in Skripten** Prozessvariablen stehen in Skripten über Autovervollständigung zur Verfügung (z. B. mit STRG + LEERTASTE). Dadurch werden Variablennamen registriert und Schreibfehler weitgehend vermieden. ## Globale Variablen Globale Variablen sind spezielle Variablen, die im CRM-System definiert und im Prozess verwendet werden können. Die Definition der globalen Variablen erfolgt in der Admin-Konsole. Sie dienen insbesondere der Verteilung von Customizing-Paketen und der systemabhängigen Konfiguration. Globale Variablen können zwischen Test-, Abnahme- und Produktivsystem unterschiedliche Werte haben. Damit lassen sich z. B. im Prozess verwendete Einstellungen je Systemumgebung unterschiedlich konfigurieren, ohne den Prozess selbst ändern zu müssen. Globale Variablen stehen erst nach entsprechender Systemkonfiguration zur Verfügung und werden üblicherweise im Rahmen des Customizings eingerichtet. ## Datentyp und automatische Synchronisierung (`IContainer`) Durch die explizite Zuweisung eines Datentyps zur Prozessvariablen ergeben sich zusätzliche Qualitäts- und Komfortfunktionen: * Bei der Variablenzuordnung in Teilprozessen kann die Typkompatibilität geprüft werden. * Variablen vom Typ `IContainer` können für eine automatische Datensynchronisierung zwischen Prozess und CRM genutzt werden. Wird für eine Variable vom Typ `IContainer` in der Bibliothek die Eigenschaft „Automatisch synchronisieren" aktiviert, kann diese im technischen Modell folgendermaßen verwendet werden: * Benutzer-Aktion * Einstellung „Detailmaske": * „Automatisch aktualisieren" (Standard: aktiviert) * „Automatisch speichern" (Standard: aktiviert) * Eingehendes Nachrichten-Zwischenereignis * „Automatisch aktualisieren" (Standard: aktiviert) * Zeitliches Zwischenereignis * „Automatisch aktualisieren" (Standard: aktiviert) Beispiele für Einschränkungen durch den Datentyp: * Benutzeraktionen, die einen Primärschlüssel benötigen, können nur noch Variablen vom Typ `PrimaryKey` aufnehmen. Die technische Typsicherheit im Skript selbst wird dadurch nicht erzwungen, aber die Konfiguration im Modell wird deutlich robuster und konsistenter. --- version: "current" language: "de" --- # BPM (alt) 📘 **BPM-Handbuch für automatisierte CRM-Prozesse (alt)** * [(alt) Einführung](https://help.cursor.de/de/bpm/current/einfuhrung.md) [(alt) CURSOR-BPM für Anwender](https://help.cursor.de/de/bpm/current/cursor-bpm-fur-anwender.md) * [(alt) Einstieg in CURSOR-BPM](https://help.cursor.de/de/bpm/current/einstieg-in-cursor-bpm.md) [(alt) Datenbereinigung](https://help.cursor.de/de/bpm/current/datenbereinigung.md) [(alt) Designer](https://help.cursor.de/de/bpm/current/designer.md) * [(alt) Tastenkombinationen für Designer-Aktionen](https://help.cursor.de/de/bpm/current/tastenkombinationen-fur-designer-aktionen.md) * [(alt) Prozessinstanzen im CRM-Datenmodell](https://help.cursor.de/de/bpm/current/prozessinstanzen-im-crm-datenmodell.md) * [(alt) Mandantenwechsel in BPM-Prozessen](https://help.cursor.de/de/bpm/current/mandantenwechsel-in-bpm-prozessen.md) [(alt) Prozessbereiche](https://help.cursor.de/de/bpm/current/prozessbereiche.md) * [(alt) Monitor](https://help.cursor.de/de/bpm/current/monitor.md) --- version: "current" language: "de" --- # BPM im Web **BPM im Web - Handbuch für automatisierte CRM-Prozesse** Mit der Version **2026.1 LTS** wurde **BPM im Web** freigegeben. Ab der Version 2026.1 LTS ist die alte BPM-Suite nicht mehr verfügbar. * [Grundlagen für Administratoren](https://help.cursor.de/de/bpm/current/grundlagen-fur-administratoren.md) * [Arbeiten mit Standardprozessen](https://help.cursor.de/de/bpm/current/arbeiten-mit-standardprozessen.md) [Erstellung, Änderung und Verwaltung von Prozessen](https://help.cursor.de/de/bpm/current/erstellung-anderung-und-verwaltung-von-prozessen.md) [Monitoring und Auswertungen](https://help.cursor.de/de/bpm/current/monitoring-und-auswertungen.md) --- version: "current" language: "de" --- # (alt) BPM-Prozesse als CRM-Anwender starten ## Einleitung BPM-Prozesse können durch verschiedene Ereignisse ausgelöst werden. Einige davon sind für CRM-Anwender nicht sichtbar, jedoch haben Sie zwei unterschiedliche Möglichkeiten, selbst BPM-Prozesse auszulösen. Wo Sie einen BPM-Prozess starten können ist dabei abhängig davon, welche Einstellung Ihr CURSOR-BPM-Administrator getroffen hat. Wenn für den Prozess von Ihnen keine weiteren Bearbeitungsschritte erforderlich sind, werden Ihnen keine weiteren Dialoge präsentiert. Werden von Ihnen jedoch weitere Eingaben bzw. Aktionen erwartet, so werden Ihnen diese in einer Maske präsentiert. Die zugehörige Bearbeitung wird in einem separaten Kapitel beschrieben Das folgende Bild beinhaltet beide Startvarianten: ![image-20240313-130128.png](https://help.cursor.de/__attachments/a_81aad8e33ff2924fb401fd745aefe5fac5ebaa6fdac3873f0a68a21f3f0d6c81/image-20240313-130128.png?cb=891974ce8299dc4fe65857834f677edc) ## Prozessstart über die Aktionsbox einer Entität Sie können Prozesse aus der Aktionsbox einer Entität (rechts am Maskenrand) starten, indem Sie in der Entität den entsprechenden Aktionsbutton klicken. Aktionsbuttons können durch Ordner analog zum myCRM-Bereich hierarhisch strukturiert werden. Gegebenenfalls klicken Sie dann die bestimmten Ordner an und starten schließlich den Prozess durch das Anklicken des jeweiligen Aktionsbuttons. ## Prozessstart über die Hauptnavigation Prozesse erreichen Sie links in der Hauptnavigation über den Bereich "Prozesse". Dort klicken Sie den gewünschten Aktionsbutton einfach an. Über das Kontextmenü können Sie sich diese Prozessstart-Buttons auch als Favoriten in der Hauptnavigation ablegen. ## Verwaltung der Aktionsbox Die Verwaltung der Aktionsbox ist dem Administrator vorbehalten. Die Aktionen können in Ordnern über das Kontextmenü und die linke Maustaste gruppiert und nachträglich kopiert, gelöscht oder ausgeblendet werden. Für modulspezifische Aktionen gelten besondere Regeln. ![image-20240313-130956.png](https://help.cursor.de/__attachments/a_f01e134fbabdf9c65e795644d9bf4cf880f487b17415521495db9dd613f614b2/image-20240313-130956.png?cb=4e0403884ef23f14d0e8a47dcc3a3b5d) Nach der Aktivierung eines Moduls ist das Attribut "Modul-Ordner ausblenden" im Popup-Menü des Modulordners standardmäßig deaktiviert. **Ausblenden eines modulspezifischen Ordners** * Im Adminmodus erscheint beim Öffnen des Kontextmenüs eines modulspezifischen Ordners zusätzlich der aktivierbare Eintrag "Modul Ordner ausblenden" (Default ist false) * Das Ausblenden von modulspezifischen C0-/C1-Ordnern wird ausschließlich in der Kundenschicht (C2) erlaubt * Das Ausblenden von modulspezifischen Ordnern steht nur immer obersten Ordner zur Verfügung * Die Visualisierung ausgeblendeter Ordner für den Admin unterscheidet sich vom Zustand bei Ordnern, deren Modul nicht verfügbar ist. Hierbei wird lediglich der Text grau dargestellt - das Ordner-Icon bleibt aktiv. Dies signalisiert, dass der Ordner geöffnet werden kann. Der ausgeblendete Ordner kann somit weiterhin geöffnet werden, um beispielsweise Einträge per Drag and Drop zu kopieren * In der persönlichen Ansicht werden * ausgeblendete modulspezifische Ordner nicht angezeigt * kopierte modulspezifische Aktionsboxeinträge angezeigt * Wird das Modul deaktiviert, so sind * im Adminmodus * sowohl die modulspezifischen Ordner als auch deren kopierte modulspezifischen Aktionsboxeinträge inaktiv (Icon und Text) * können die kopierten modulspezifischen Aktionsboxeinträge entfernt werden * in der persönlichen Ansicht * wird der modulspezifische Ordner nicht angezeigt * werden die kopierten modulspezifischen Aktionsboxeinträge nicht angezeigt **Kopieren modulspezifischer Aktionsboxeinträge** Das Kopieren eines modulspezifischen Aktionseintrags ist per Drag and Drop in den Root-Ordner möglich (über die Navigationsleiste) * Das Verschieben eines Eintrags erfolgt mit gedrückter linker Maustaste * Das Kopieren eines Eintrags erfolgt per Kombination aus gedrückter STRG -Taste und gedrückter linker Maustaste * Der kopierte modulspezifische Aktionseintrag kann wie ein normaler Aktionseintrag verschoben oder kopiert werden * Das Verschieben eines modulspezifischen Aktionseintrags per Drag and Drop ist nicht erlaubt Der modulspezifische Ordner ist nicht änderbar. Das Verschieben oder Kopieren eines modulspezifischen Unterordners ist nicht möglich. Bearbeiten von modulspezifischen Aktionseinträgen: im Falle der kopierten und originalen modulspezifischen Aktionseinträge kann weiterhin nur die Internationalisierung über den I18n-Schalter geändert werden --- version: "current" language: "de" --- # CRM-Detailmaske ## Grundlagen CRM-Detailmasken (z.B. Geschäftspartner, Ansprechpartner, Anschlussobjekte) können direkt in BPM-Prozessabläufe integriert werden. Dadurch lassen sich die Möglichkeiten von CURSOR-BPM mit dem CRM-Customizing kombinieren und Anwender können Daten in der gewohnten Ansicht eingeben und ändern. ![grafik-20260209-185215.png](https://help.cursor.de/__attachments/a_a53c43e86bcd22b16f96d04b98cd89a310896767fc4375c02b90888ea84e4232/grafik-20260209-185215.png?cb=1f7f8f6ad63f014ca2d9cd343a3f628b) *Neuanlage eines Ansprechpartners im Lead-Prozess* Im Geschäftsprozessmanagement werden im Wesentlichen zwei Prozesstypen unterschieden: 1. **Normative Prozesse** Prozesse mit klar vorgegebenen, eng geführten Handlungsschritten. 2. **Dynamisches bzw. adaptives Case Management** Prozesse, die zwar einen Rahmen (Abläufe, Beteiligte) vorgeben, den Bearbeitenden jedoch große Freiheitsgrade lassen. Im Prozessablauf öffnet sich für die verantwortliche Person die im Prozess definierte CRM-Detailmaske mit allen Standardfunktionen und implementierten Sonderlogiken. Auf diese Weise lassen sich sehr flexible Prozesse umsetzen, ohne zusätzliche BPM-Dialoge definieren zu müssen. Wird in einem Prozessschritt eine CRM-Detailmaske geöffnet, erscheinen in der Buttonleiste anstelle des normalen Datensatz-Headers und der Buttonleiste zusätzlich: * die Phasenübersicht, * Informationen zum Prozessschritt und * die Prozessnavigationsleiste. So werden BPM- und CRM-Funktionen in einer Oberfläche kombiniert. Durch die integrierten CRM-Masken können zu den angezeigten Daten (in der Maske oder im Suchergebnis) Aktionen ausgeführt werden, zum Beispiel: * Löschen von Datensätzen aus einer Liste * Zuordnen von Daten im Unterbereich (z. B. Verknüpfen von Objekten) Zudem können bestehende Client-Logiken in CRM-Masken einfacher in BPM-Benutzeraktionen abgebildet werden (z. B. Angebotsbearbeitung inkl. Positionen). Viele Tätigkeiten sind so vielfältig, dass sie sich in starren BPM-Masken nicht sinnvoll darstellen lassen, in CRM-Masken jedoch schon. ## Konfiguration der Einbindung von Detailmasken Die Einbindung von CRM-Detailmasken in einem BPM-Prozess wird wie folgt konfiguriert: 1. In der Benutzer-Aktion im technischen Modell den Typ „CRM-Detailmaske" auswählen. 2. Die relevante CRM-Entität angeben, * die im Datenmodell ausgewählt sein muss oder * per Variable bereitgestellt wird. 3. Die Variable auswählen, die den Primärschlüssel des zu öffnenden Datensatzes enthält. * Zulässig sind nur Variablen vom Typ `Object` oder `PrimaryKey`. 4. Alternativ kann eine IContainer-Variable mit gültigem Primärschlüssel übergeben werden. 5. Festlegen, ob beim Klick auf Weiter nach Bearbeitung des Prozessschritts die CRM-Detailmaske geschlossen werden soll. * Standard ist „nein", d. h. die Entität bleibt nach Abschluss des Prozessschritts geöffnet. * Das Schließen erfolgt nur, wenn der Datensatz in der obersten Ebene (Hauptknoten) geöffnet ist. 6. Alternativ kann der Prozess bereits beim Öffnen der Benutzeraktion weitergeführt werden. * Wichtig: Der Prozess erhält dann keine nachträglich geänderten Daten des geöffneten Datensatzes mehr. * Diese Option sollte nur kurz vor Prozessende verwendet werden. **Anmerkungen** * Die Aktionen werden wie gewohnt über die Task-Liste angeboten. Es öffnet sich jedoch keine BPM-Maske, sondern die CRM-Standardmaske mit Phasenübersicht und Fortführen-Schalter. * Ist der Datensatz bereits in der Detailansicht geöffnet, wird keine neue Ebene geöffnet; lediglich die Phasenübersicht wird eingeblendet. * Die Phasenübersicht ist auch sichtbar, wenn der Datensatz nicht über die Taskliste, sondern z. B. über die normale CRM-Suchmaske geöffnet wurde. * Nach Abschluss der Benutzeraktion wird die Phasenübersicht wieder ausgeblendet. * Je nach Konfiguration wird die Standardmaske geschlossen. * Folgt auf die Benutzer-Aktion eine weitere Aktion für denselben Anwender, wird diese direkt im Anschluss zur Bearbeitung angeboten. ## Zugriff auf geöffnete Prozess-Benutzer-Aktionen in CRM-Masken Werden offene Prozessaktionen in CRM-Detailmasken bearbeitet, kann der zugehörige Prozessschritt per Maskenskript programmatisch fortgeführt werden. Im Skript wird dabei der Klick auf **Weiter** ( ALT + W ) simuliert. Dazu stehen im Maskenskript der CRM-Entitäten folgende Methoden zur Verfügung: * `TaskUtils.complete()` Simuliert das Auslösen der Weiter-Betätigung (Klick auf das Weiter-Symbol bzw. Tastenkombination ALT + W ) und schließt den aktuellen Prozessschritt ab. * `TaskUtils.isEntityLinkedToTask(String processId)` Prüft, ob der aktuell geladene Datensatz mit einer Benutzer-Aktion verknüpft ist. * Gibt `true` zurück, wenn eine Verknüpfung besteht. * Über den Parameter `processId` kann die Prüfung auf einen bestimmten Prozess eingeschränkt werden. Beide Methoden setzen voraus, dass die Benutzer-Aktion in der Detailmaske der CRM-Entität aktuell geöffnet ist. Sie sind daher nicht geeignet für Benutzer-Aktionen, die nur einer Benutzergruppe (ohne konkrete, aktuell geöffnete Detailmaske) zugeordnet sind. --- version: "current" language: "de" --- # (alt) CRM-Standardmasken in BPM ## Grundlagen Sie können Ihre individuell angepassten CRM-Masken jetzt in BPM-Prozessabläufe integrieren. Damit kombinieren Sie die Möglichkeiten vom CURSOR-BPM mit Ihren individuellen Anpassungen (Customizing) in den CRM-Masken. Das ist sinnvoll, da es im Geschäftsprozessmanagement grundsätzlich zwei Arten von Prozesstypen gibt: 1. zum einen Prozesse, mit denen den Anwendern ganz enge Handlungsmöglichkeiten vorgegeben werden (sogenannte "Normative Prozesse"), und 2. zum anderen solche, die zwar grundsätzlich Abläufe und Beteiligte erfordern, aber den Verantwortlichen in der Durchführung der jeweiligen Aufgabe große Freiheiten lassen (sogenanntes "dynamisches bzw. adaptives Case Management"). Den ersten Fall hat Ihnen CURSOR-BPM bislang schon durch die speziellen BPM-Masken geboten. Jetzt können Sie auch Prozesse des zweiten Typs umsetzen, indem Sie statt spezieller BPM-Dialog Ihre CURSOR-CRM-Entitätsmasken integrieren. Im Prozessablauf öffnet sich für den verantwortlichen Mitarbeiter dann die im Prozess definierte CURSOR-CRM-Entitätsmasken mit allen Standardbedienungsmöglichkeiten und der bei Ihnen realisierten Sonderlogiken. So können Sie effizient ohne die Definition separater Dialoge sehr flexible Prozesse umsetzen. Damit bieten wir Ihnen jetzt schon die Möglichkeiten eines iBPMS (intelligentes Business Process Management System). Erreichen Sie in einem Prozessschritt eine CRM-Standardmaske, so werden zusätzlich dort wie sonst in Prozessmasken auch die Phasenübersicht, die zusätzlichen Informationen zum Prozessschritt und die Prozessnavigationsleiste eingeblendet: so haben Sie Sie die Vorteile von BPM und CRM bestens kombiniert. Durch die integrierten CRM-Masken können Sie zu den angezeigten Daten (auf der Maske oder im Suchergebnis) Aktionen ausgeführten, die es im BPM-GUI bisher nicht gab: * Löschen aus einer Liste * Zuordnen von Daten im Unterbereich etc. Zudem werden einige Client-Logiken in den CRM-Masken einfacher in BPM-Benutzeraktionen abgebildet werden (z.B. Angebotsbearbeitung inkl. Positionen). Diese Tätigkeiten des Anwenders sind teilweise auch so vielfältig, dass sich nicht alle Aufgaben in den BPM-Masken abbilden ließen. ## Einbindung von CRM-Detailmasken im CURSOR-BPM **So konfigurieren Sie die Einbindung von CRM-Detailmasken im CURSOR-BPM** * Auswahl einer Benutzer-Aktion im technischen Modell, dort neuen Typ **CRM-Detailmaske auswählen** * Relevante CRM-Entität angeben, die im Datenmodell ausgewählt sein muss oder per Variable bereitsteht * Variable auswählen, die den Primärschlüssel enthält, mit dem die CRM-Detailmaske geöffnet werden soll (daher sind nur Variablen vom Typ **Object** oder **PrimaryKey** zulässig) * Alternativ kann eine **IContainer**-Variable mit gültigen Primärschlüssel übergeben werden * Definition, ob nach der Prozessschrittbearbeitung der Klick auf **Weiter** die CRM-Detailmaske geschlossen werden soll. Die Default-Vorbelegung ist "nein", so dass für den Anwender die relevante Entität geöffnet bleibt. Das Schließen der Maske wird nur ausgeführt, wenn der Datensatz in der obersten Ebene (Hauptknoten) geöffnet ist. * Alternativ kann der Prozess auch beim Öffnen der Benutzeraktion weitergeführt werden. Der Prozess enthält aber dann nicht mehr die aktualisierten Daten des geöffneten Datensatzes falls dieser nachträglich durch den Anwender bearbeitet wird. Es ist ratsam diese Option nur vor dem Prozessende zu setzen. ![BPM_CRMMask_191031_0730.png](https://help.cursor.de/__attachments/a_40ae67ae9065b30241464ff478c08e2733e3e424b0e795a17f317f5a75b22a1c/BPM_CRMMask_191031_0730.png?cb=32b176d0f430fe161021fb5dd4b610f8) *Abbildung: Einbindung von CRM-Standard-Masken* Anmerkungen: * Diese Aktionen werden ganz normal über die Task-Liste dem Anwender angeboten. Es öffnet sich aber nicht die BPM-Maske, sondern die CRM-Standard-Maske mit der Phasen-Übersicht und dem Schalter zum Fortführen der Prozess-Instanz. * Ist der Datensatz aktuell in der Detailansicht geöffnet, so öffnet sich bei einer neuen Aktion keine neue Ebene aber die Phasenübersicht wird in der aktuellen Detailansicht eingeblendet. * Die Phasenansicht ist auch sichtbar, wenn man den Datensatz nicht über die Taskliste öffnet, sondern z.B. über die normale CRM-Suchmaske. * Nach Abschluss der Benutzeraktion wird die Phasen-Übersicht wieder ausgeblendet. * Je nach konfigurierter Option wird die Standard-Maske geschlossen. * Folgt der Benutzer-Aktion eine weitere Benutzer-Aktion für den aktuellen Anwender, so wird ihm diese direkt zur Bearbeitung angeboten. ![CRM-5955_projectmask.png](https://help.cursor.de/__attachments/a_b8d70b5c332326ec4a3588821bb8f49e2165201749e1880989feaa4919ff9760/CRM-5955_projectmask.png?cb=9be5018e329c62537acf40098fd55f2b) *Abbildung: CRM-Maske im BPM-Prozess* ## Auf geöffnete Prozess-Benutzer-Aktionen in CRM-Masken zugreifen **So können Sie als Administrator per Maskenskript-Zugriff auf geöffnete Prozess-Benutzer-Aktionen in CRM-Masken zugreifen** Durch die Integration von CRM-Detailmasken können Anwender jetzt offene Aktionen wie beschrieben in den CRM-Standardmasken bearbeiten. Ist für eine Benutzer-Aktion ein Datensatz von einem Anwender zur Bearbeitung geladen, dann können Sie per Maskenskript den Prozess fortführen. Im Skript simulieren Sie so den Klick des Anwenders auf das "Weiter"-Symbol bzw. die zugehörige Tastenkombiniation ALT + W . Dazu stehen Ihnen die beiden folgenden Methoden im Maskenskript der CRM-Entitäten zur Verfügung: * `TaskUtils.complete()`: diese Methode simuliert das Auslösen der "Weiter"-Betätigung (Klick des Anwenders auf das "Weiter"-Symbol bzw. Aufruf der zugehörigen Tastenkombiniation ALT + W . Dadurch wird der Prozess-Schritt abgeschlossen. * `TaskUtils.isEntityLinkedToTask(String processId)`: Mit dieser Methoden können Sie prüfen, ob ein Datensatz mit einer Benutzer-Aktion verbunden ist. In diesem Fall liefert die Methode **true** zurück. Durch die Angabe des Parameters `ProzessID` können Sie die Prüfung auf genau diesen Prozess einschränken. Diese Methoden setzen voraus, dass die Benutzer-Aktion in der Detailmaske der CRM-Entität aktuell geöffnet ist, so dass sie für Benutzer-Aktionen, die einer Benutzergruppe zugeordnet sind, nicht angewendet werden können. --- version: "current" language: "de" --- # CTI-Server-Statusänderung Der Prozess wird durch die Änderung des Status am CTI-Server oder CTI-Telefon gestartet. **Permanente Parameter** * eventName: `CTI_STATE_CHANGE` * ctiStateEvent: Die Statusinformation des CTI Servers als `CstaServerEvent`-Objekt. Dieses kann über die Klasse `CstaScriptUtils` verarbeitet werden. --- version: "current" language: "de" --- # (alt) CURSOR-BPM für Anwender **Kleines Handbuch für BPM-Anwender** * [(alt) Einführung in CURSOR-BPM für CRM-Anwender](https://help.cursor.de/de/bpm/current/einfuhrung-in-cursor-bpm-fur-crm-anwender.md) * [(alt) Offene Aktionen öffnen](https://help.cursor.de/de/bpm/current/offene-aktionen-offnen.md) * [(alt) BPM-Prozesse als CRM-Anwender starten](https://help.cursor.de/de/bpm/current/bpm-prozesse-als-crm-anwender-starten.md) * [(alt) Prozessschritte bearbeiten](https://help.cursor.de/de/bpm/current/prozessschritte-bearbeiten.md) * [(alt) Tastenkombinationen für Benutzer-Aktionen](https://help.cursor.de/de/bpm/current/tastenkombinationen-fur-benutzer-aktionen.md) --- version: "current" language: "de" --- # (alt) Datenbereinigung ## Grundlagen Zu jeder abgeschlossenen Prozess-Instanz und Instanz-Aktion werden in der Datenbank durch die Prozess-Engine große Datenmengen historisiert. Diese Daten werden für Prozess-Auswertungen benötigt. Doch gibt es technische Prozesse, deren historisierte Daten nicht benötigt werden. Zudem sind Daten, die mehrere Jahre zurückliegen, nicht mehr interessant. Um die historisierten Daten zu bereinigen, kann nun jeder Prozess einem Datenbereinigungs-Job zugewiesen werden. Die Datenbereinigung ist an den Customizing-Transport angebunden. ## Definition Im Standard werden drei Bereinigungsdefinitionen ausgeliefert. Neue Prozesse werden der Datenbereinigung SHORT zugewiesen. Ein Löschlauf besteht immer aus 2 Stufen. * Skript-Prozesse ohne Auswertung (SHORT) 1. Löschen von historischen Instanzinformationen - Standard 1 Tag 2. Löschen von alten Prozessdefinitionen - Standard 2 Jahre * Interaktionsprozesse mit kurzem Auswertungszeitraum (MEDIUM) 1. Löschen von historischen Instanzinformationen - Standard 1 Monat 2. Löschen von alten Prozessdefinitionen - Standard 2 Jahre * Interaktionsprozesse mit langem Auswertungszeitraum (DEFAULT) 1. Löschen von historischen Instanzinformationen - Standard 1 Jahr 2. Löschen von alten Prozessdefinitionen - Standard 2 Jahre Zu jedem Job gibt es 2 Datumseinstellungen getrennt nach jeweils Jahr (max 99.), Monat (max. 11) und Tag (max 30). Die Einstellungen berechnen einen Wert in Tagen, wie alt die Einträge sein müssen, bevor sie gelöscht werden. Beispiel: 1 Jahr, 6 Monate, 7 Tage =\> 1\*365 + 6\*30 + 7 = 742 Tage ![CRM-2264_CleanJobView.png](https://help.cursor.de/__attachments/a_7b2c399510934845de8f3f4fe4f260ccbf6524885c9c231a122d5fd850f11725/CRM-2264_CleanJobView.png?cb=6ae009bbdf7d129bbece685b078cc159) Die Zeitangabe der Prozessdefinition ist dabei immer größer als die der Instanzinformationen. Jeder Datenbereinigung können nun Prozesse zugewiesen werden. Die bisherige Zuordnung wird entfernt. Die Zuordnung kann nur für Prozesse aus der der aktuellen Customizing-Schicht erfolgen. Bei übersteuerten Prozessen gilt die Zuordnung auch für die zu Grunde liegenden Standard- oder Partnermodul-Prozesse. ![CRM-2264_AssignCleanJob.png](https://help.cursor.de/__attachments/a_3288d250c8d670cf57ad7993aea58789f616c5c75198ae1fdad96c9b797ecf22/CRM-2264_AssignCleanJob.png?cb=a0e09920515462bf8911319577ab9d09) ## Ausführung Die Datenbereinigung startet über den Timer **Systemtabellen bereinigen**. Dieser startet im Standard einmal pro Tag. ![CRM-2264_CleanJobTimer.png](https://help.cursor.de/__attachments/a_db5f4117b735bdbe0b8b3be076747d61346c3f055576e393e66857a9a3a85e02/CRM-2264_CleanJobTimer.png?cb=ef1eba48d29b09cf4a887fdd0806ec91) Je nach Bereinigungs-Stufe werden unterschiedliche Daten der Prozesshistorie gelöscht. Die Löschung kann nicht rückgängig gemacht werden. ### Bereinigung der Instanzinformationen Die erste Stufe löscht die Hauptdatenmenge der Prozess-Historie. Hierzu zählen die Prozessvariablen und Aktionsinformationen auch für Benutzeraktionen. * Tabellen * ACT_HI_VARINST -\> ACT_GE_BYTEARRAY * ACT_HI_ACTINST -\> ACT_HI_TASKINST, ACT_HI_IDENTITYLINK * ACT_HI_PROCINST * ACT_RE_PROCDEF, ACT_RE_DEPLOYMENT * ProcessInstance * ProcessWaitState * ProcessErrorLog #### Beeinträchtigung in BPM Auswertungen sind nur noch bis zum letzten Bereinigungszeitraum möglich. Der Startcount und die Abschluss-Übersicht werden verfälscht. ### Bereinigung von Prozessdefinitionen Die zweite Stufe löscht alte Versionen von Prozess-Definitionen, die in CURSOR-BPM erstellt wurden, zu denen es aber keine Instanzinformationen gibt. * Tabellen * ProcessContainer, ProcessModel * ProcessMask, ProcessSearch * Translation #### Beeinträchtigung in BPM Es ist kein alter Stand "potentiell" wiederherstellbar. ### Ausführung bei noch laufenden kritischen Prozessen verhindern Es kann sein, dass langlaufende Prozesse mit großen Transaktionen zu derselben Zeit wie die Datenbereinigung laufen und es dabei zu Datenbanksperren kommen kann. Um Probleme bei solchen kritischen Prozessen mit der Datenbank zu vermeiden, können diese Prozesse als Anwendungsvariable hinterlegt werden. Die über ein Systemtimer gestartete Aktion zur Bereinigung der Daten innerhalb der Activiti-Tabellen prüft beim Start, ob aktuell noch kritische Prozesse am Laufen sind. Ist dies der Fall, läuft die Datenbereinigung nicht los sondern es erfolgt * ein entsprechender Log-Eintrag * eine Mail-Benachrichtigung an den System-Zuständigen (zentraler Empfänger für Service-Anforderungen im System) Der Vermerk "kritischer Prozess" erfolgt über eine Anwendungsvariable, in der die Prozessnamen der wichtigen Prozesse festgehalten werden können. Der Absender der Mail-Benachrichtigung wird in den Systemeinstellungen hinterlegt. ![CRM-11083_SuspendCleanJobProcesses.png](https://jira.cursor.de/secure/attachment/70061/CRM-11083_SuspendCleanJobProcesses.png) ## Konfigurationsvorschlag Die Datenbereinigung sollte in Testsystemen und Produktivsystemen unterschiedlich eingesetzt werden. Bei Verwendung des Customizingtransports, sollte man erst die Datenbereinigung auf Entwicklung-/Testsystem mit besonderen Einstellungen durchführen, danach die Einstellungen wechseln und diese auf das Produktivsystem übertragen. ### Datenbereinigung im Testsystem In einem Testsystem werden die Prozesse entwickelt. Damit entstehen von einem Prozess eine Vielzahl von Prozessversionen, deren Prozessdefinition mit der Zeit die Datenbank und die Servercaches belastet. Daher ist es notwendig, dort die alten Prozess-Versionen aufzuräumen. Prinzipiell sollte man immer zwischendurch einen Prozessstand extern durch einen Export sichern. Die folgenden Einstellungen, sind hierfür sinnvoll: * DEFAULT * Instanzinformationen: 1 Monat * Prozessdefinitionen: 1 Monat * MEDIUM/SHORT * Prozessdefinitionen: 1 Monat Natürlich werden die Prozessdefinitionen von noch aktiv laufenden Prozessen nicht gelöscht. Die letzte Version eines Prozesses bleibt immer erhalten. ### Datenbereinigung im Produktivsystem Nachdem die Datenbereinigung im Testsystem durchgeführt wurde, sollte die DEFAULT Konfiguration wieder auf den Standard zurückgestellt werden. Im Produktivsystem gibt es meist nur 3 Kategorien von Prozessen: 1. Prozesse, die zeitgesteuert gestartet werden und/oder reine serverseitige Logiken ausführen 2. Prozess mit Benutzerinteraktion, deren Laufzeit aber immer unter einem Tag liegt 3. Prozess mit Benutzerinteraktion mit einer Laufzeit über mehrere Tage oder sogar Wochen Lange laufende Prozessinstanzen, sind eine gute Grundlage für die Auswertung von Liegezeiten und Bearbeitungszeiten. Reine serverseitige Ausführungen dagegen, haben eine viel zu kurze Laufzeit, um dies sinnvoll auswerten zu können. Diese werden aber meist sehr häufig ausgeführt, was zu einer hohen Datenlast führen kann. Um herauszufinden wie oft welcher Prozess ausgeführt wurde, kann folgendes SQL-Statement verwendet werden. SQL SELECT ACT_RE_PROCDEF.NAME_, COUNT(ACT_HI_PROCINST.ID_) AS count FROM ACT_RE_PROCDEF,ACT_HI_PROCINST WHERE ACT_HI_PROCINST.PROC_DEF_ID_ = ACT_RE_PROCDEF.ID_ GROUP BY ACT_RE_PROCDEF.NAME_ ORDER BY count DESC Für die oben genannten Prozesskategorien, solle man auch drei verschiedene Datenbereinigungs-Einstellungen verwenden und die Prozesse dem entsprechend zuweisen. ### Ungültige Variablen löschen In älteren Version kann es dazu kommen, das Variablen vom Typ IScriptWorkSpace für laufende aber wartende Instanzen in der Datenbank verblieben sind. Durch ein Update werden die Variablen ungültig und müssen gelöscht werden. SQL /* Selection der Prozess-Instanzen */ SELECT ACT_HI_PROCINST.* FROM ACT_RU_EXECUTION, ACT_RU_VARIABLE, ACT_HI_PROCINST WHERE ACT_HI_PROCINST.ID_ = ACT_RU_EXECUTION.PROC_INST_ID_ AND ACT_RU_EXECUTION.ID_ = ACT_RU_VARIABLE.EXECUTION_ID_ AND ACT_RU_VARIABLE.NAME_ = 'workSpace' /* Selection der Prozess-Ids */ SELECT DISTINCT NAME_ FROM ACT_RE_PROCDEF WHERE ID_ IN (SELECT ACT_RU_EXECUTION.PROC_DEF_ID_ FROM ACT_RU_EXECUTION, ACT_RU_VARIABLE WHERE ACT_RU_EXECUTION.ID_ = ACT_RU_VARIABLE.EXECUTION_ID_ AND ACT_RU_VARIABLE.NAME_ = 'workSpace') Diese Variablen können aus den Instanzen problemlos gelöscht werden, da sie nach Ablauf einer Client-Session ungültig sind. SQL /* BLOB-History-Daten löschen */ DELETE FROM ACT_GE_BYTEARRAY WHERE ID_ IN (SELECT BYTEARRAY_ID_ FROM ACT_HI_VARINST WHERE NAME_ = 'workSpace') /* ORACLE */ CREATE TABLE TMPACT_GE_BYTEARRAY AS (SELECT BYTEARRAY_ID_ FROM ACT_RU_VARIABLE WHERE NAME_ = 'workSpace') /* MSSQL /* SELECT BYTEARRAY_ID_ INTO TMPACT_GE_BYTEARRAY FROM ACT_RU_VARIABLE WHERE NAME_ = 'workSpace' /* Variablen löschen */ DELETE FROM ACT_HI_VARINST WHERE NAME_ = 'workSpace' DELETE FROM ACT_RU_VARIABLE WHERE NAME_ = 'workSpace' /* BLOB-Runtime-Daten löschen */ DELETE FROM ACT_GE_BYTEARRAY WHERE ID_ IN (SELECT BYTEARRAY_ID_ FROM TMPACT_GE_BYTEARRAY) DROP TABLE TMPACT_GE_BYTEARRAY --- version: "current" language: "de" --- # (alt) Datenbereinigung von großen Datenmengen ## Einführung Vor oder direkt nach einem Update müssen diese Daten initial einmal manuell per Datenbank-Statements bereinigt werden, um danach die korrekten Bereinigungsjob einzurichten. Je kürzer die Zeitspanne im Bereinigungsjob ist, desto weniger Daten werden in den Tabellen der Activiti-Prozess-Engine gesammelt. Die nachfolgenden Statements unterscheiden sich für MSSQL und ORACLE nur in der Datumsangabe (`getdate()` bzw. `sysdate()`). Um sich einen Überblick über Anzahl der Prozessinstanzen pro Prozess zu verschaffen, sollte man vor jeder manuellen Bereinigung das Ergebnis folgende Statements anschauen: ### **Anzahl der noch laufenden Prozess-Instanzen** SQL SELECT ProcessId,Count(ProcessId) AS count FROM ProcessInstance GROUP BY ProcessId ORDER BY count DESC **Anzahl der Prozess-Instanzen** SQL SELECT ACT_RE_PROCDEF.NAME_, COUNT(ACT_HI_PROCINST.ID_) AS count FROM ACT_RE_PROCDEF, ACT_HI_PROCINST WHERE ACT_HI_PROCINST.PROC_DEF_ID_ = ACT_RE_PROCDEF.ID_ /* AND START_TIME_ < (SYSDATE - 100) AND END_TIME_ IS NULL */ GROUP BY ACT_RE_PROCDEF.NAME_ ORDER BY count DESC **Anzahl der durchlaufenen Aktionen pro Prozess** SQL SELECT ACT_RE_PROCDEF.NAME_, COUNT(ACT_HI_ACTINST.ID_) AS count FROM ACT_RE_PROCDEF, ACT_HI_PROCINST, ACT_HI_ACTINST WHERE ACT_HI_PROCINST.PROC_DEF_ID_ = ACT_RE_PROCDEF.ID_ AND ACT_HI_ACTINST.PROC_INST_ID_ = ACT_HI_PROCINST.ID_ GROUP BY ACT_RE_PROCDEF.NAME_ ORDER BY count DESC ; Mit diesen Statements kann man die Prozesse identifizieren, die die meisten Daten in den Prozess-Tabellen hinterlassen, obwohl für diese Prozesse keine Auswertung über CURSOR-BPM notwendig ist. ## Bereinigung im Testsystem Im Testsystem sind nur Testdaten enthalten. Hier können die Prozess-Tabellen vollständig und effizient aufgeräumt werden. **Warnung** Die folgenden Statements löschen laufende Instanzen genauso wie alle historisierten Daten. Nur die veröffentlichten Prozess-Definitionen bleiben in den Activiti-Tabellen erhalten. Bevor diese Statements abgesetzt werden, sollte der JBoss-Applikationsserver des Testsystems beendet werden. Die Reihenfolge der Statements muss genau eingehalten werden! ### **Runtime-Tabellen löschen** SQL TRUNCATE TABLE ACT_RU_VARIABLE; TRUNCATE TABLE ACT_RU_JOB; TRUNCATE TABLE ACT_RU_TIMER_JOB; TRUNCATE TABLE ACT_RU_SUSPENDED_JOB; TRUNCATE TABLE ACT_RU_DEADLETTER_JOB; TRUNCATE TABLE ACT_RU_IDENTITYLINK; TRUNCATE TABLE ACT_RU_TASK; TRUNCATE TABLE ACT_RU_EXECUTION; TRUNCATE TABLE ACT_RU_INTEGRATION; /* Teilweise kann ein TRUNCATE unter ORCALE wegen Fehler der referenzieller Integrität nicht abgesetzt werden. Dieses muss dann durch ein DELETE mit anschließender Tabellen-Verkleinerung ersetzt werden. */ TRUNCATE TABLE ACT_RU_VARIABLE; TRUNCATE TABLE ACT_RU_JOB; TRUNCATE TABLE ACT_RU_TIMER_JOB; TRUNCATE TABLE ACT_RU_SUSPENDED_JOB; TRUNCATE TABLE ACT_RU_DEADLETTER_JOB; TRUNCATE TABLE ACT_RU_IDENTITYLINK; TRUNCATE TABLE ACT_RU_INTEGRATION; DELETE FROM ACT_RU_EVENT_SUBSCR WHERE PROC_INST_ID_ IS NOT NULL; DELETE FROM ACT_RU_TASK; ALTER TABLE ACT_RU_TASK enable row movement; ALTER TABLE ACT_RU_TASK shrink space cascade; ALTER TABLE ACT_RU_TASK disable row movement; DELETE FROM ACT_RU_EXECUTION; ALTER TABLE ACT_RU_EXECUTION enable row movement; ALTER TABLE ACT_RU_EXECUTION shrink space cascade; ALTER TABLE ACT_RU_EXECUTION disable row movement; Es gilt zu beachten, dass die History-Tabellen auch Daten zu den laufenden Instanzen enthalten. #### **History-Tabellen löschen** SQL TRUNCATE TABLE ACT_HI_VARINST; TRUNCATE TABLE ACT_HI_ACTINST; TRUNCATE TABLE ACT_HI_TASKINST; TRUNCATE TABLE ACT_HI_IDENTITYLINK; TRUNCATE TABLE ACT_HI_PROCINST; Die Tabelle ACT_GE_BYTEARRAY enthält Prozess-Variablen und das Deployment der Prozesse. Wird die Tabelle komplett geleert, müssen alle Prozesse neu veröffentlicht werden! ##### **Blob-Tabelle löschen** SQL DELETE FROM ACT_GE_BYTEARRAY WHERE Deployment_Id_ IS NULL; /* Unter ORACLE sollte die Tabelle nach dem DELETE verkleinert werden. */ ALTER TABLE ACT_GE_BYTEARRAY enable row movement; ALTER TABLE ACT_GE_BYTEARRAY shrink space cascade; ALTER TABLE ACT_GE_BYTEARRAY disable row movement; /* Falls es sich um ein 'secure file LOB' Segment handelt, muss ein anderes Statement zum Verkleinern genutzt werden: https://oracle-base.com/articles/misc/alter-table-shrink-space-online */ ALTER TABLE ACT_GE_BYTEARRAY MOVE LOB(BYTES_) STORE AS (TABLESPACE ) /* Indices der Tabelle ACT_GE_BYTEARRAY müssen neu aufgebaut werden */ declare v_cursor integer := DBMS_SQL.OPEN_CURSOR; begin for v_rec in ( select * from USER_INDEXES where index_type in ('NORMAL', 'FUNCTION-BASED NORMAL') and table_name = 'ACT_GE_BYTEARRAY' ) loop DBMS_SQL.PARSE( v_cursor , 'ALTER INDEX '||v_rec.INDEX_NAME||' REBUILD ' , DBMS_SQL.NATIVE ); end loop; DBMS_SQL.CLOSE_CURSOR(v_cursor); end; Die im CRM enthaltenen Prozess-Tabellen müssen auch bereinigt werden. SQL TRUNCATE TABLE ProcessInstance; TRUNCATE TABLE ProcessWaitStat; TRUNCATE TABLE ProcessErrorLog; ## Bereinigung im Produktiv-System Im Produktiv-System dürfen auf keinen Fall die laufenden Prozessinstanzen gelöscht werden. Dies kann in Ausnahmefällen gemacht werden, wenn * Prozesse durch Anwender nicht ordnungsgemäß beendet werden, * offene Instanzen auf Grund von Fehlern liegen geblieben sind * oder einzelne Prozesse durch Schleifen endlos laufen. Auch die Prozess-Historie wird teilweise für die Laufzeit-Auswertung von Prozessen benötigt. Hierfür ist es zwingend notwendig die fachlichen Anforderungen der Prozesse zu berücksichtigen und sich einen genauen Überblick über die Anzahl an Instanzen pro Prozess zu verschaffen. Meist sind es nur wenige Prozesse, die 95% des Platzes der Activiti-Tabellen belegen. Genau diese Prozesse müssen manuell bereinigt werden, bevor ab Version 16.1 die Bereinigungsjobs eingerichtet werden können. ### Fehlerhaft laufende Instanzen löschen Diese Aktion ist optional, wenn im System keine fehlerhaften Instanzen vorhanden sind oder diese über die CURSOR-BPM Oberfläche entfernt werden können. Für eine genauere Prüfung können die Instanzinformationen aus der Tabelle `ProcessInstance` ermittelt werden #### **Informationen zu laufenden Prozessen** SQL SELECT ProcessId, ActivitiName, InstanceId, StartUser, UserId, UpdateDate FROM ProcessInstance Alle betroffenen Instanzen müssen in einer temporären Tabelle gesammelt werden. Die Einschränkungen sind kundenindividuell zu ermitteln. ##### **Temporäre Tabelle TMP_ACT_RU_PROCINST** SQL CREATE TABLE TMP_ACT_RU_PROCINST AS (SELECT InstanceId FROM ProcessInstance WHERE ProcessId IN ('...') /* AND ActivitiName LIKE '%...' */ ); /* Alle laufenden Instanzen löschen */ CREATE TABLE TMP_ACT_RU_PROCINST AS (SELECT DISTINCT PROC_INST_ID_ AS InstanceId FROM ACT_RU_EXECUTION); /* Instanzen die älter 100 Tage sind löschen */ CREATE TABLE TMP_ACT_RU_PROCINST AS (SELECT ID_ AS InstanceId FROM ACT_HI_PROCINST WHERE START_TIME_ < (SYSDATE - 100) AND END_TIME_ IS NULL); /* Alle laufenden Instanzen eines bestimmten Prozesses löschen */ CREATE TABLE TMP_ACT_RU_PROCINST AS (SELECT ACT_HI_PROCINST.ID_ AS InstanceId FROM ACT_RE_PROCDEF, ACT_HI_PROCINST WHERE ACT_HI_PROCINST.PROC_DEF_ID_ = ACT_RE_PROCDEF.ID_ AND ACT_RE_PROCDEF.NAME_ = '...' ); Mit Hilfe dieser temporären Tabelle können nun die Runtime-Informationen der Prozesse gelöscht werden. ###### **laufende Prozess-Instanzen löschen** SQL DELETE FROM ACT_HI_PROCINST WHERE ID_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST); **Laufzeit-Variablen löschen** SQL CREATE TABLE TMP_ACT_RU_BYTEARRAY AS (SELECT BYTEARRAY_ID_ FROM ACT_RU_VARIABLE WHERE BYTEARRAY_ID_ IS NOT NULL AND PROC_INST_ID_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST)); DELETE FROM ACT_RU_VARIABLE WHERE PROC_INST_ID_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_GE_BYTEARRAY where ID_ IN (SELECT BYTEARRAY_ID_ FROM TMP_ACT_RU_BYTEARRAY); DROP TABLE TMP_ACT_RU_BYTEARRAY; **Offene Benutzer-Aktionen löschen** SQL CREATE TABLE TMP_ACT_RU_TASK AS (SELECT ID_ FROM ACT_RU_TASK WHERE PROC_INST_ID_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST)); DELETE FROM ACT_RU_IDENTITYLINK WHERE PROC_INST_ID_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_IDENTITYLINK WHERE TASK_ID_ IN (SELECT ID_ FROM TMP_ACT_RU_TASK); DELETE FROM ACT_RU_TASK WHERE PROC_INST_ID_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST); DROP TABLE TMP_ACT_RU_TASK; **Offen Ausführungen löschen** SQL DELETE FROM ACT_RU_JOB WHERE PROCESS_INSTANCE_ID_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_TIMER_JOB WHERE PROCESS_INSTANCE_ID_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_SUSPENDED_JOB WHERE PROCESS_INSTANCE_ID_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_DEADLETTER_JOB WHERE PROCESS_INSTANCE_ID_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_EVENT_SUBSCR WHERE PROC_INST_ID_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_INTEGRATION WHERE PROCESS_INSTANCE_ID_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_EXECUTION WHERE SUPER_EXEC_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_EXECUTION WHERE PROC_INST_ID_ IN (SELECT InstanceId FROM TMP_ACT_RU_PROCINST); **Temporäre Tabelle löschen** SQL DROP TABLE TMP_ACT_RU_PROCINST; Nun wurden alle Laufzeit-Informationen aus den Activiti-Tabellen für die vorher abgestimmte Selektion entfernt. Es gibt aber noch Daten in den History-Tabellen, die auch für die laufenden Instanzen gelten. Die Kopf-Daten aus der Tabelle `ACT_HI_PROCINST` wurden gelöscht. Alle Fremdschlüssel-Beziehungen sind daher ungültig und müssen zusätzlich noch gelöscht werden. (Siehe 'Bereinigung abhängiger Daten') ###### **Laufende Instanzen in MSSQL bereinigen** SQL SELECT ACT_HI_PROCINST.ID_ INTO TMP_ACT_RU_PROCINST FROM ACT_RE_PROCDEF, ACT_HI_PROCINST WHERE ACT_HI_PROCINST.PROC_DEF_ID_ = ACT_RE_PROCDEF.ID_ AND ACT_RE_PROCDEF.NAME_ = '...' AND END_TIME_ IS NULL) AND START_TIME_ < (GETDATE() - 1); DELETE FROM ACT_HI_PROCINST WHERE ID_ IN (SELECT ID_ FROM TMP_ACT_RU_PROCINST); SELECT BYTEARRAY_ID_ INTO TMP_ACT_RU_BYTEARRAY FROM ACT_RU_VARIABLE WHERE BYTEARRAY_ID_ IS NOT NULL AND PROC_INST_ID_ IN (SELECT ID_ FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_VARIABLE WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_GE_BYTEARRAY where ID_ IN (SELECT BYTEARRAY_ID_ FROM TMP_ACT_RU_BYTEARRAY); DROP TABLE TMP_ACT_RU_BYTEARRAY; SELECT ID_ INTO TMP_ACT_RU_TASK FROM ACT_RU_TASK WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_IDENTITYLINK WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_IDENTITYLINK WHERE TASK_ID_ IN (SELECT ID_ FROM TMP_ACT_RU_TASK); DELETE FROM ACT_RU_TASK WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMP_ACT_RU_PROCINST); DROP TABLE TMP_ACT_RU_TASK; DELETE FROM ACT_RU_JOB WHERE PROCESS_INSTANCE_ID_ IN (SELECT ID_ FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_TIMER_JOB WHERE PROCESS_INSTANCE_ID_ IN (SELECT ID_ FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_SUSPENDED_JOB WHERE PROCESS_INSTANCE_ID_ IN (SELECT ID_ FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_DEADLETTER_JOB WHERE PROCESS_INSTANCE_ID_ IN (SELECT ID_ FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_EVENT_SUBSCR WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_EXECUTION WHERE SUPER_EXEC_ IN (SELECT ID_ FROM TMP_ACT_RU_PROCINST); DELETE FROM ACT_RU_EXECUTION WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMP_ACT_RU_PROCINST); DROP TABLE TMP_ACT_RU_PROCINST; ### Historie für Prozesse löschen Für jede abgeschlossene Prozessinstanz gibt es einen Eintrag in der Tabelle `ACT_HI_PROCINST`. Bei sehr häufig laufenden Prozessen, können daher pro Tag mehrere hundert Einträge erzeugt werden. Diese Prozesse sind sehr oft Skriptprozesse, die im Hintergrund laufen und über CURSOR-CRM nicht ausgewertet werden. Diese Prozessinstanzen sollten über die Bereinigungsjobs jeden Tag aufgeräumt werden. Das folgende Statement kann auch mehrmals für verschiedene Prozesse mit anderen Zeitangaben (monatlich anstatt täglich) gestartet werden. #### **Abgeschlossene Prozessinstanzen löschen** SQL DELETE FROM ACT_HI_PROCINST WHERE END_TIME_ IS NOT NULL AND END_TIME_ < (SYSDATE - 1) /* für MSSQL (GETDATE() - 1) */ AND PROC_DEF_ID_ IN (SELECT pd.ID_ FROM ACT_RE_PROCDEF pd WHERE pd.NAME_ IN ('XXX')) /*'XXX' kann durch die IDs der Prozesse ersetzt werden */ ### Bereinigung abhängiger Daten Wurde fehlerhafte laufende Prozessinstanzen und die Historie von Skriptprozessen gelöscht, so enthalten noch weitere Einträge Zusatzinformationen zu diesen Prozessinstanzen. Diese Statements können je nach Datenmenge mehrere Stunden benötigen. #### **Abhängige Daten bereinigen** SQL /* Altdaten in Hisotry-Tabellen */ DELETE FROM ACT_GE_BYTEARRAY where ID_ IN (SELECT BYTEARRAY_ID_ FROM ACT_HI_VARINST WHERE PROC_INST_ID_ NOT IN (SELECT ID_ FROM ACT_HI_PROCINST)); DELETE FROM ACT_HI_VARINST WHERE PROC_INST_ID_ NOT IN (SELECT ID_ FROM ACT_HI_PROCINST); DELETE FROM ACT_HI_ACTINST WHERE PROC_INST_ID_ NOT IN (SELECT ID_ FROM ACT_HI_PROCINST); DELETE FROM ACT_HI_IDENTITYLINK WHERE TASK_ID_ NOT IN (SELECT ID_ FROM ACT_HI_TASKINST); DELETE FROM ACT_HI_TASKINST WHERE PROC_INST_ID_ NOT IN (SELECT ID_ FROM ACT_HI_PROCINST); /* Altdaten in CRM-Tabellen */ DELETE FROM ProcessInstance WHERE Active = 0; DELETE FROM ProcessInstance WHERE InstanceId NOT IN (SELECT ID_ FROM ACT_HI_PROCINST); DELETE FROM ProcessWaitStat WHERE Active = 0; DELETE FROM ProcessErrorLog WHERE Active = 0 OR ProcessInstance NOT IN (SELECT ID_ FROM ACT_HI_PROCINST); ### Verkleinerung der Datenbank-Tabellen Durch die vielen Löschungen der Tabellen sind diese unter ORACLE fragmentiert und die Datenbank-Dateien haben noch ihre ursprüngliche Größe von Teilweise mehren GB. Es ist ratsam alle Tabellen zu verkleinern, damit die Datenbank Performance wieder steigt. #### **ORACLE shrink-Befehle** SQL /* BLOB Tabelle */ ALTER TABLE ACT_GE_BYTEARRAY enable row movement; ALTER TABLE ACT_GE_BYTEARRAY shrink space cascade; ALTER TABLE ACT_GE_BYTEARRAY disable row movement; /* Falls es sich um ein 'secure file LOB' Segment handelt, muss ein anderes Statement zum Verkleinern genutzt werden: https://oracle-base.com/articles/misc/alter-table-shrink-space-online */ ALTER TABLE ACT_GE_BYTEARRAY MOVE LOB(BYTES_) STORE AS (TABLESPACE ) /* Indices der Tabelle ACT_GE_BYTEARRAY müssen neu aufgebaut werden */ declare v_cursor integer := DBMS_SQL.OPEN_CURSOR; begin for v_rec in ( select * from USER_INDEXES where index_type in ('NORMAL', 'FUNCTION-BASED NORMAL') and table_name = 'ACT_GE_BYTEARRAY' ) loop DBMS_SQL.PARSE( v_cursor , 'ALTER INDEX '||v_rec.INDEX_NAME||' REBUILD ' , DBMS_SQL.NATIVE ); end loop; DBMS_SQL.CLOSE_CURSOR(v_cursor); end; /* Runtime Tabellen */ ALTER TABLE ACT_RU_VARIABLE enable row movement; ALTER TABLE ACT_RU_VARIABLE shrink space cascade; ALTER TABLE ACT_RU_VARIABLE disable row movement; ALTER TABLE ACT_RU_JOB enable row movement; ALTER TABLE ACT_RU_JOB shrink space cascade; ALTER TABLE ACT_RU_JOB disable row movement; ALTER TABLE ACT_RU_TIMER_JOB enable row movement; ALTER TABLE ACT_RU_TIMER_JOB shrink space cascade; ALTER TABLE ACT_RU_TIMER_JOB disable row movement; ALTER TABLE ACT_RU_SUSPENDED_JOB enable row movement; ALTER TABLE ACT_RU_SUSPENDED_JOB shrink space cascade; ALTER TABLE ACT_RU_SUSPENDED_JOB disable row movement; ALTER TABLE ACT_RU_DEADLETTER_JOB enable row movement; ALTER TABLE ACT_RU_DEADLETTER_JOB shrink space cascade; ALTER TABLE ACT_RU_DEADLETTER_JOB disable row movement; ALTER TABLE ACT_RU_EVENT_SUBSCR enable row movement; ALTER TABLE ACT_RU_EVENT_SUBSCR shrink space cascade; ALTER TABLE ACT_RU_EVENT_SUBSCR disable row movement; ALTER TABLE ACT_RU_IDENTITYLINK enable row movement; ALTER TABLE ACT_RU_IDENTITYLINK shrink space cascade; ALTER TABLE ACT_RU_IDENTITYLINK disable row movement; ALTER TABLE ACT_RU_TASK enable row movement; ALTER TABLE ACT_RU_TASK shrink space cascade; ALTER TABLE ACT_RU_TASK disable row movement; ALTER TABLE ACT_RU_EXECUTION enable row movement; ALTER TABLE ACT_RU_EXECUTION shrink space cascade; ALTER TABLE ACT_RU_EXECUTION disable row movement; ALTER TABLE ACT_RU_INTEGRATION enable row movement; ALTER TABLE ACT_RU_INTEGRATION shrink space cascade; ALTER TABLE ACT_RU_INTEGRATION disable row movement; /* History Tabellen */ ALTER TABLE ACT_HI_VARINST enable row movement; ALTER TABLE ACT_HI_VARINST shrink space cascade; ALTER TABLE ACT_HI_VARINST disable row movement; ALTER TABLE ACT_HI_ACTINST enable row movement; ALTER TABLE ACT_HI_ACTINST shrink space cascade; ALTER TABLE ACT_HI_ACTINST disable row movement; ALTER TABLE ACT_HI_IDENTITYLINK enable row movement; ALTER TABLE ACT_HI_IDENTITYLINK shrink space cascade; ALTER TABLE ACT_HI_IDENTITYLINK disable row movement; ALTER TABLE ACT_HI_PROCINST enable row movement; ALTER TABLE ACT_HI_PROCINST shrink space cascade; ALTER TABLE ACT_HI_PROCINST disable row movement; ALTER TABLE ACT_HI_TASKINST enable row movement; ALTER TABLE ACT_HI_TASKINST shrink space cascade; ALTER TABLE ACT_HI_TASKINST disable row movement; /* CRM Tabellen */ ALTER TABLE ProcessInstance enable row movement; ALTER TABLE ProcessInstance shrink space cascade; ALTER TABLE ProcessInstance disable row movement; ALTER TABLE ProcessWaitStat enable row movement; ALTER TABLE ProcessWaitStat shrink space cascade; ALTER TABLE ProcessWaitStat disable row movement; ALTER TABLE ProcessErrorLog enable row movement; ALTER TABLE ProcessErrorLog shrink space cascade; ALTER TABLE ProcessErrorLog disable row movement; ## Vollständige Bereinigung Für die Bereinigungs-Statements muss der JBoss heruntergefahren werden, damit keine Prozesse zur selben Zeit arbeiten. ### **Vollständige Bereinigung unter ORACLE** SQL /*** Produktiv- bzw. Test-System mit Sicherungen und Truncates bereinigen ***/ /*** Der JBoss muss heruntergefahren werden - LAufzeit ca 15-30min ***/ /*** Trennzeichen im SQL-Editor: ?%! ***/ /*** Ab hier das SQL-Skript in den SQL-Editor kopieren ***/ /* 01: constraints deaktivieren */ BEGIN /* 1. constraint */ FOR v_rec IN ( SELECT * FROM User_Constraints WHERE Constraint_Type = 'C' AND Table_Name IN ('ACT_GE_BYTEARRAY','ACT_RE_DEPLOYMENT','ACT_RE_MODEL','ACT_RU_EXECUTION','ACT_RU_JOB','ACT_RU_TIMER_JOB','ACT_RU_SUSPENDED_JOB','ACT_RU_DEADLETTER_JOB','ACT_RE_PROCDEF','ACT_RU_TASK','ACT_RU_IDENTITYLINK','ACT_RU_VARIABLE','ACT_RU_EVENT_SUBSCR','ACT_EVT_LOG','ACT_PROCDEF_INFO','ACT_RU_INTEGRATION') ) LOOP EXECUTE IMMEDIATE 'ALTER TABLE '||v_rec.Table_name||' DISABLE CONSTRAINT '||v_rec.constraint_name; END LOOP; /* 2. foreign key */ FOR v_rec IN ( SELECT * FROM User_Constraints WHERE Constraint_Type = 'R' AND Table_Name IN ('ACT_GE_BYTEARRAY','ACT_RE_DEPLOYMENT','ACT_RE_MODEL','ACT_RU_EXECUTION','ACT_RU_JOB','ACT_RU_TIMER_JOB','ACT_RU_SUSPENDED_JOB','ACT_RU_DEADLETTER_JOB','ACT_RE_PROCDEF','ACT_RU_TASK','ACT_RU_IDENTITYLINK','ACT_RU_VARIABLE','ACT_RU_EVENT_SUBSCR','ACT_EVT_LOG','ACT_PROCDEF_INFO','ACT_RU_INTEGRATION') ) LOOP EXECUTE IMMEDIATE 'ALTER TABLE '||v_rec.Table_name||' DISABLE CONSTRAINT '||v_rec.constraint_name; END LOOP; /* 3. primary key */ FOR v_rec IN ( SELECT * FROM User_Constraints WHERE Constraint_Type = 'P' AND Table_Name IN ('ACT_GE_BYTEARRAY','ACT_RE_DEPLOYMENT','ACT_RE_MODEL','ACT_RU_EXECUTION','ACT_RU_JOB','ACT_RU_TIMER_JOB','ACT_RU_SUSPENDED_JOB','ACT_RU_DEADLETTER_JOB','ACT_RE_PROCDEF','ACT_RU_TASK','ACT_RU_IDENTITYLINK','ACT_RU_VARIABLE','ACT_RU_EVENT_SUBSCR','ACT_EVT_LOG','ACT_PROCDEF_INFO','ACT_RU_INTEGRATION') ) LOOP EXECUTE IMMEDIATE 'ALTER TABLE '||v_rec.Table_name||' DISABLE CONSTRAINT '||v_rec.constraint_name; END LOOP; END; ?%! /* 02: Laufzeitdaten und History von 30 Tagen sichern */ CREATE TABLE TMPACT_HI_PROCINST_ID AS (SELECT ID_ FROM ACT_HI_PROCINST WHERE END_TIME_ IS NULL) ?%! INSERT INTO TMPACT_HI_PROCINST_ID (SELECT ID_ FROM ACT_HI_PROCINST WHERE END_TIME_ IS NOT NULL AND END_TIME_ > (SYSDATE - 30)) ?%! CREATE TABLE TMPACT_HI_PROCINST AS (SELECT * FROM ACT_HI_PROCINST WHERE ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID))?%! CREATE TABLE TMPACT_HI_ACTINST AS (SELECT * FROM ACT_HI_ACTINST WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID))?%! CREATE TABLE TMPACT_HI_TASKINST AS (SELECT * FROM ACT_HI_TASKINST WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID))?%! CREATE TABLE TMPACT_HI_IDENTITYLINK AS (SELECT * FROM ACT_HI_IDENTITYLINK WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID))?%! CREATE TABLE TMPACT_HI_VARINST AS (SELECT * FROM ACT_HI_VARINST WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID))?%! CREATE TABLE TMPACT_HI_DETAIL AS (SELECT * FROM ACT_HI_DETAIL WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID))?%! CREATE TABLE TMPACT_ACT_GE_BYTEARRAY_ID AS (SELECT ID_ FROM ACT_GE_BYTEARRAY WHERE DEPLOYMENT_ID_ IS NOT NULL)?%! INSERT INTO TMPACT_ACT_GE_BYTEARRAY_ID (SELECT BYTEARRAY_ID_ FROM ACT_RU_VARIABLE WHERE BYTEARRAY_ID_ IS NOT NULL)?%! INSERT INTO TMPACT_ACT_GE_BYTEARRAY_ID (SELECT EXCEPTION_STACK_ID_ FROM ACT_RU_JOB WHERE EXCEPTION_STACK_ID_ IS NOT NULL)?%! INSERT INTO TMPACT_ACT_GE_BYTEARRAY_ID (SELECT EXCEPTION_STACK_ID_ FROM ACT_RU_TIMER_JOB WHERE EXCEPTION_STACK_ID_ IS NOT NULL)?%! INSERT INTO TMPACT_ACT_GE_BYTEARRAY_ID (SELECT EXCEPTION_STACK_ID_ FROM ACT_RU_SUSPENDED_JOB WHERE EXCEPTION_STACK_ID_ IS NOT NULL)?%! INSERT INTO TMPACT_ACT_GE_BYTEARRAY_ID (SELECT EXCEPTION_STACK_ID_ FROM ACT_RU_DEADLETTER_JOB WHERE EXCEPTION_STACK_ID_ IS NOT NULL)?%! INSERT INTO TMPACT_ACT_GE_BYTEARRAY_ID (SELECT BYTEARRAY_ID_ FROM ACT_HI_VARINST WHERE BYTEARRAY_ID_ IS NOT NULL AND PROC_INST_ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID))?%! CREATE TABLE TMPACT_GE_BYTEARRAY AS (SELECT * FROM ACT_GE_BYTEARRAY WHERE ID_ IN (SELECT ID_ FROM TMPACT_ACT_GE_BYTEARRAY_ID))?%! CREATE TABLE TMPACT_ProcessInstance AS (SELECT * FROM ProcessInstance WHERE InstanceId IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID))?%! CREATE TABLE TMPACT_ProcessErrorLog AS (SELECT * FROM ProcessErrorLog WHERE ProcessInstance IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID))?%! CREATE TABLE TMPACT_ProcessWaitStat AS (SELECT * FROM ProcessWaitStat WHERE InternalProcessId IN (SELECT ID_ FROM ACT_RU_EXECUTION))?%! DROP TABLE TMPACT_ACT_GE_BYTEARRAY_ID?%! DROP TABLE TMPACT_HI_PROCINST_ID?%! /* 03: Tabelle leeren */ TRUNCATE TABLE ACT_HI_PROCINST?%! TRUNCATE TABLE ACT_HI_ACTINST?%! TRUNCATE TABLE ACT_HI_TASKINST?%! TRUNCATE TABLE ACT_HI_IDENTITYLINK?%! TRUNCATE TABLE ACT_HI_VARINST?%! TRUNCATE TABLE ACT_HI_DETAIL?%! TRUNCATE TABLE ACT_GE_BYTEARRAY?%! TRUNCATE TABLE ProcessInstance?%! TRUNCATE TABLE ProcessErrorLog?%! TRUNCATE TABLE ProcessWaitStat?%! /* 04: gültige Daten zurückspielen */ INSERT INTO ACT_HI_PROCINST (select * from TMPACT_HI_PROCINST)?%! INSERT INTO ACT_HI_ACTINST (select * from TMPACT_HI_ACTINST)?%! INSERT INTO ACT_HI_TASKINST (select * from TMPACT_HI_TASKINST)?%! INSERT INTO ACT_HI_IDENTITYLINK (select * from TMPACT_HI_IDENTITYLINK)?%! INSERT INTO ACT_HI_VARINST (select * from TMPACT_HI_VARINST)?%! INSERT INTO ACT_HI_DETAIL (select * from TMPACT_HI_DETAIL)?%! INSERT INTO ACT_GE_BYTEARRAY (select * from TMPACT_GE_BYTEARRAY)?%! INSERT INTO ProcessInstance (select * from TMPACT_ProcessInstance)?%! INSERT INTO ProcessErrorLog (select * from TMPACT_ProcessErrorLog)?%! INSERT INTO ProcessWaitStat (select * from TMPACT_ProcessWaitStat)?%! /* 05: Tmp Tabellen löschen */ DROP TABLE TMPACT_HI_PROCINST?%! DROP TABLE TMPACT_HI_ACTINST?%! DROP TABLE TMPACT_HI_TASKINST?%! DROP TABLE TMPACT_HI_IDENTITYLINK?%! DROP TABLE TMPACT_HI_VARINST?%! DROP TABLE TMPACT_HI_DETAIL?%! DROP TABLE TMPACT_GE_BYTEARRAY?%! DROP TABLE TMPACT_ProcessInstance?%! DROP TABLE TMPACT_ProcessErrorLog?%! DROP TABLE TMPACT_ProcessWaitStat?%! /* 06: constraints aktivieren */ BEGIN /* 1. primary key */ FOR v_rec IN ( SELECT * FROM User_Constraints WHERE Constraint_Type = 'P' AND Table_Name IN ('ACT_GE_BYTEARRAY','ACT_RE_DEPLOYMENT','ACT_RE_MODEL','ACT_RU_EXECUTION','ACT_RU_JOB','ACT_RU_TIMER_JOB','ACT_RU_SUSPENDED_JOB','ACT_RU_DEADLETTER_JOB','ACT_RE_PROCDEF','ACT_RU_TASK','ACT_RU_IDENTITYLINK','ACT_RU_VARIABLE','ACT_RU_EVENT_SUBSCR','ACT_EVT_LOG','ACT_PROCDEF_INFO','ACT_RU_INTEGRATION') ) LOOP EXECUTE IMMEDIATE 'ALTER TABLE '||v_rec.Table_name||' ENABLE CONSTRAINT '||v_rec.constraint_name; END LOOP; /* 2. foreign key */ FOR v_rec IN ( SELECT * FROM User_Constraints WHERE Constraint_Type = 'R' AND Table_Name IN ('ACT_GE_BYTEARRAY','ACT_RE_DEPLOYMENT','ACT_RE_MODEL','ACT_RU_EXECUTION','ACT_RU_JOB','ACT_RU_TIMER_JOB','ACT_RU_SUSPENDED_JOB','ACT_RU_DEADLETTER_JOB','ACT_RE_PROCDEF','ACT_RU_TASK','ACT_RU_IDENTITYLINK','ACT_RU_VARIABLE','ACT_RU_EVENT_SUBSCR','ACT_EVT_LOG','ACT_PROCDEF_INFO','ACT_RU_INTEGRATION') ) LOOP EXECUTE IMMEDIATE 'ALTER TABLE '||v_rec.Table_name||' ENABLE CONSTRAINT '||v_rec.constraint_name; END LOOP; /* 3. constraint */ FOR v_rec IN ( SELECT * FROM User_Constraints WHERE Constraint_Type = 'C' AND Table_Name IN ('ACT_GE_BYTEARRAY','ACT_RE_DEPLOYMENT','ACT_RE_MODEL','ACT_RU_EXECUTION','ACT_RU_JOB','ACT_RU_TIMER_JOB','ACT_RU_SUSPENDED_JOB','ACT_RU_DEADLETTER_JOB','ACT_RE_PROCDEF','ACT_RU_TASK','ACT_RU_IDENTITYLINK','ACT_RU_VARIABLE','ACT_RU_EVENT_SUBSCR','ACT_EVT_LOG','ACT_PROCDEF_INFO','ACT_RU_INTEGRATION') ) LOOP EXECUTE IMMEDIATE 'ALTER TABLE '||v_rec.Table_name||' ENABLE CONSTRAINT '||v_rec.constraint_name; END LOOP; END; ?%! **Vollständige Bereinigung unter MSSQL** SQL /*** Produktiv-System mit Sicherungen und Truncates bereinigen ***/ /*** Trennzeichen im SQL-Editor: ; ***/ /*** Ab hier das SQL-Skript in den SQL-Editor kopieren ***/ /* 01: constraints deaktivieren */ /* Dieses Statement manuell ausführen und dann Ergebniszeilen als Skript ausführen */ SELECT 'ALTER TABLE ' + Table_name + ' NOCHECK CONSTRAINT ' + constraint_name + ';' FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE Table_Name IN ('ACT_GE_BYTEARRAY','ACT_RE_DEPLOYMENT','ACT_RE_MODEL','ACT_RU_EXECUTION','ACT_RU_JOB','ACT_RU_TIMER_JOB','ACT_RU_SUSPENDED_JOB','ACT_RU_DEADLETTER_JOB','ACT_RE_PROCDEF','ACT_RU_TASK','ACT_RU_IDENTITYLINK','ACT_RU_VARIABLE','ACT_RU_EVENT_SUBSCR','ACT_EVT_LOG','ACT_PROCDEF_INFO','ACT_RU_INTEGRATION') AND CONSTRAINT_TYPE in ('FOREIGN KEY') /* 02: Laufzeitdaten und History von 10 Tagen sichern */ SELECT ID_ INTO TMPACT_HI_PROCINST_ID FROM ACT_HI_PROCINST WHERE END_TIME_ IS NULL; INSERT INTO TMPACT_HI_PROCINST_ID SELECT ID_ FROM ACT_HI_PROCINST WHERE END_TIME_ IS NOT NULL AND END_TIME_ > (GETDATE() - 10) ; SELECT * INTO TMPACT_HI_PROCINST FROM ACT_HI_PROCINST WHERE ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID); SELECT * INTO TMPACT_HI_ACTINST FROM ACT_HI_ACTINST WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID); SELECT * INTO TMPACT_HI_TASKINST FROM ACT_HI_TASKINST WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID); SELECT * INTO TMPACT_HI_IDENTITYLINK FROM ACT_HI_IDENTITYLINK WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID); SELECT * INTO TMPACT_HI_VARINST FROM ACT_HI_VARINST WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID); SELECT * INTO TMPACT_HI_DETAIL FROM ACT_HI_DETAIL WHERE PROC_INST_ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID); SELECT ID_ INTO TMPACT_ACT_GE_BYTEARRAY_ID FROM ACT_GE_BYTEARRAY WHERE DEPLOYMENT_ID_ IS NOT NULL; INSERT INTO TMPACT_ACT_GE_BYTEARRAY_ID SELECT BYTEARRAY_ID_ FROM ACT_RU_VARIABLE WHERE BYTEARRAY_ID_ IS NOT NULL; INSERT INTO TMPACT_ACT_GE_BYTEARRAY_ID SELECT EXCEPTION_STACK_ID_ FROM ACT_RU_JOB WHERE EXCEPTION_STACK_ID_ IS NOT NULL; INSERT INTO TMPACT_ACT_GE_BYTEARRAY_ID SELECT EXCEPTION_STACK_ID_ FROM ACT_RU_TIMER_JOB WHERE EXCEPTION_STACK_ID_ IS NOT NULL; INSERT INTO TMPACT_ACT_GE_BYTEARRAY_ID SELECT EXCEPTION_STACK_ID_ FROM ACT_RU_SUSPENDED_JOB WHERE EXCEPTION_STACK_ID_ IS NOT NULL; INSERT INTO TMPACT_ACT_GE_BYTEARRAY_ID SELECT EXCEPTION_STACK_ID_ FROM ACT_RU_DEADLETTER_JOB WHERE EXCEPTION_STACK_ID_ IS NOT NULL; INSERT INTO TMPACT_ACT_GE_BYTEARRAY_ID SELECT BYTEARRAY_ID_ FROM ACT_HI_VARINST WHERE BYTEARRAY_ID_ IS NOT NULL AND PROC_INST_ID_ IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID); SELECT * INTO TMPACT_GE_BYTEARRAY FROM ACT_GE_BYTEARRAY WHERE ID_ IN (SELECT ID_ FROM TMPACT_ACT_GE_BYTEARRAY_ID); SELECT * INTO TMPACT_ProcessInstance FROM ProcessInstance WHERE InstanceId IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID); SELECT * INTO TMPACT_ProcessErrorLog FROM ProcessErrorLog WHERE ProcessInstance IN (SELECT ID_ FROM TMPACT_HI_PROCINST_ID); SELECT * INTO TMPACT_ProcessWaitStat FROM ProcessWaitStat WHERE InternalProcessId IN (SELECT ID_ FROM ACT_RU_EXECUTION); DROP TABLE TMPACT_ACT_GE_BYTEARRAY_ID; DROP TABLE TMPACT_HI_PROCINST_ID; /* 03: constraints löschen */ ALTER TABLE ACT_RU_JOB DROP CONSTRAINT ACT_FK_JOB_EXCEPTION ALTER TABLE ACT_RU_TIMER_JOB DROP CONSTRAINT ACT_FK_TIMER_JOB_EXCEPTION ALTER TABLE ACT_RU_SUSPENDED_JOB DROP CONSTRAINT ACT_FK_SUSPENDED_JOB_EXCEPTION ALTER TABLE ACT_RU_DEADLETTER_JOB DROP CONSTRAINT ACT_FK_DEADLETTER_JOB_EXCEPTION ALTER TABLE ACT_RU_VARIABLE DROP CONSTRAINT ACT_FK_VAR_BYTEARRAY ALTER TABLE ACT_RE_MODEL DROP CONSTRAINT ACT_FK_MODEL_SOURCE ALTER TABLE ACT_RE_MODEL DROP CONSTRAINT ACT_FK_MODEL_SOURCE_EXTRA ALTER TABLE ACT_PROCDEF_INFO DROP CONSTRAINT ACT_FK_INFO_JSON_BA; ALTER TABLE ACT_GE_BYTEARRAY DROP CONSTRAINT ID_ACT_GE_BYTEARRAY --Für ältere Versionen: Hier muss geprüft werden, welcher Name wirklich vergeben worden ist, da das Suffix generiert ist. --ALTER TABLE ACT_GE_BYTEARRAY DROP CONSTRAINT PK__ACT_GE_B__XXXX /* 04: Tabelle leeren */ TRUNCATE TABLE ACT_HI_PROCINST; TRUNCATE TABLE ACT_HI_ACTINST; TRUNCATE TABLE ACT_HI_TASKINST; TRUNCATE TABLE ACT_HI_IDENTITYLINK; TRUNCATE TABLE ACT_HI_VARINST; TRUNCATE TABLE ACT_HI_DETAIL; TRUNCATE TABLE ACT_GE_BYTEARRAY; TRUNCATE TABLE ProcessInstance; TRUNCATE TABLE ProcessErrorLog; TRUNCATE TABLE ProcessWaitStat; /* 05: gültige Daten zurückspielen */ INSERT INTO ACT_HI_PROCINST select * from TMPACT_HI_PROCINST; INSERT INTO ACT_HI_ACTINST select * from TMPACT_HI_ACTINST; INSERT INTO ACT_HI_TASKINST select * from TMPACT_HI_TASKINST; INSERT INTO ACT_HI_IDENTITYLINK select * from TMPACT_HI_IDENTITYLINK; INSERT INTO ACT_HI_VARINST select * from TMPACT_HI_VARINST; INSERT INTO ACT_HI_DETAIL select * from TMPACT_HI_DETAIL; INSERT INTO ACT_GE_BYTEARRAY select * from TMPACT_GE_BYTEARRAY; INSERT INTO ProcessInstance select * from TMPACT_ProcessInstance; INSERT INTO ProcessErrorLog select * from TMPACT_ProcessErrorLog; INSERT INTO ProcessWaitStat select * from TMPACT_ProcessWaitStat; /* 06: Tmp Tabellen löschen */ DROP TABLE TMPACT_HI_PROCINST; DROP TABLE TMPACT_HI_ACTINST; DROP TABLE TMPACT_HI_TASKINST; DROP TABLE TMPACT_HI_IDENTITYLINK; DROP TABLE TMPACT_HI_VARINST; DROP TABLE TMPACT_HI_DETAIL; DROP TABLE TMPACT_GE_BYTEARRAY; DROP TABLE TMPACT_ProcessInstance; DROP TABLE TMPACT_ProcessErrorLog; DROP TABLE TMPACT_ProcessWaitStat; /* 07: constraints erstellen */ ALTER TABLE [dbo].[ACT_GE_BYTEARRAY] ADD CONSTRAINT [ID_ACT_GE_BYTEARRAY] PRIMARY KEY CLUSTERED ( [ID_] ASC ) WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, FILLFACTOR = 70) ON [PRIMARY]; ALTER TABLE [dbo].[ACT_RU_JOB] WITH NOCHECK ADD CONSTRAINT [ACT_FK_JOB_EXCEPTION] FOREIGN KEY([EXCEPTION_STACK_ID_]) REFERENCES [dbo].[ACT_GE_BYTEARRAY] ([ID_]); ALTER TABLE [dbo].[ACT_RU_TIMER_JOB] WITH NOCHECK ADD CONSTRAINT [ACT_FK_TIMER_JOB_EXCEPTION] FOREIGN KEY([EXCEPTION_STACK_ID_]) REFERENCES [dbo].[ACT_GE_BYTEARRAY] ([ID_]); ALTER TABLE [dbo].[ACT_RU_SUSPENDED_JOB] WITH NOCHECK ADD CONSTRAINT [ACT_FK_SUSPENDED_JOB_EXCEPTION] FOREIGN KEY([EXCEPTION_STACK_ID_]) REFERENCES [dbo].[ACT_GE_BYTEARRAY] ([ID_]); ALTER TABLE [dbo].[ACT_RU_DEADLETTER_JOB] WITH NOCHECK ADD CONSTRAINT [ACT_FK_DEADLETTER_JOB_EXCEPTION] FOREIGN KEY([EXCEPTION_STACK_ID_]) REFERENCES [dbo].[ACT_GE_BYTEARRAY] ([ID_]); ALTER TABLE [dbo].[ACT_RU_VARIABLE] WITH NOCHECK ADD CONSTRAINT [ACT_FK_VAR_BYTEARRAY] FOREIGN KEY([BYTEARRAY_ID_]) REFERENCES [dbo].[ACT_GE_BYTEARRAY] ([ID_]); ALTER TABLE [dbo].[ACT_RE_MODEL] WITH NOCHECK ADD CONSTRAINT [ACT_FK_MODEL_SOURCE] FOREIGN KEY([EDITOR_SOURCE_VALUE_ID_]) REFERENCES [dbo].[ACT_GE_BYTEARRAY] ([ID_]); ALTER TABLE [dbo].[ACT_RE_MODEL] WITH NOCHECK ADD CONSTRAINT [ACT_FK_MODEL_SOURCE_EXTRA] FOREIGN KEY([EDITOR_SOURCE_EXTRA_VALUE_ID_]) REFERENCES [dbo].[ACT_GE_BYTEARRAY] ([ID_]); ALTER TABLE [dbo].[ACT_PROCDEF_INFO] WITH NOCHECK ADD CONSTRAINT [ACT_FK_INFO_JSON_BA] FOREIGN KEY([INFO_JSON_ID_]) REFERENCES [dbo].[ACT_GE_BYTEARRAY] ([ID_]); ALTER TABLE [dbo].[ACT_RU_JOB] NOCHECK CONSTRAINT [ACT_FK_JOB_EXCEPTION]; ALTER TABLE [dbo].[ACT_RU_TIMER_JOB] NOCHECK CONSTRAINT [ACT_FK_TIMER_JOB_EXCEPTION]; ALTER TABLE [dbo].[ACT_RU_SUSPENDED_JOB] NOCHECK CONSTRAINT [ACT_FK_SUSPENDED_JOB_EXCEPTION]; ALTER TABLE [dbo].[ACT_RU_DEADLETTER_JOB] NOCHECK CONSTRAINT [ACT_FK_DEADLETTER_JOB_EXCEPTION]; ALTER TABLE [dbo].[ACT_RU_VARIABLE] NOCHECK CONSTRAINT [ACT_FK_VAR_BYTEARRAY]; ALTER TABLE [dbo].[ACT_RE_MODEL] NOCHECK CONSTRAINT [ACT_FK_MODEL_SOURCE]; ALTER TABLE [dbo].[ACT_RE_MODEL] NOCHECK CONSTRAINT [ACT_FK_MODEL_SOURCE_EXTRA]; ALTER TABLE [dbo].[ACT_PROCDEF_INFO] NOCHECK CONSTRAINT [ACT_FK_INFO_JSON_BA]; /* 08: constraints aktivieren */ /* Dieses Statement manuell ausführen und dann Ergebniszeilen als Skript ausführen */ SELECT 'ALTER TABLE ' + Table_name + ' CHECK CONSTRAINT ' + constraint_name + ';' FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE Table_Name IN ('ACT_GE_BYTEARRAY','ACT_RE_DEPLOYMENT','ACT_RE_MODEL','ACT_RU_EXECUTION','ACT_RU_JOB','ACT_RU_TIMER_JOB','ACT_RU_SUSPENDED_JOB','ACT_RU_DEADLETTER_JOB','ACT_RE_PROCDEF','ACT_RU_TASK','ACT_RU_IDENTITYLINK','ACT_RU_VARIABLE','ACT_RU_EVENT_SUBSCR','ACT_EVT_LOG','ACT_PROCDEF_INFO','ACT_RU_INTEGRATION') AND CONSTRAINT_TYPE in ('FOREIGN KEY'); [Next Page](https://help.cursor.de/llms-full.txt/1)