Expecco Overview/en: Unterschied zwischen den Versionen

Aus expecco Wiki (Version 2.x)
Zur Navigation springen Zur Suche springen
Zeile 81: Zeile 81:
However, it allows "code injection" for Java, .NET and Python applications, thus "grey box" and "white box" tests are also possible.
However, it allows "code injection" for Java, .NET and Python applications, thus "grey box" and "white box" tests are also possible.


In expecco, test scenarios can be formulated on a high level of abstractionas (activity) diagrams, as "keyword-driven" test sequences or as textual scripts in various programming languages. Scripts can be executed in expecco itself as well as in the [[Glossary/en#SUT_.28System_Under_Test.29|SUT]] or other machines (e.g. to stimulate the SUT or to generate load).
In expecco, test scenarios can be formulated on a high level of abstraction as (activity) diagrams, as "keyword-driven" test sequences or as textual scripts in various programming languages. Scripts can be executed in expecco itself as well as in the [[Glossary/en#SUT_.28System_Under_Test.29|SUT]] or other machines (e.g. to stimulate the SUT or to generate load).


The following rough architecture picture gives an overview (not all available plugins are included):
The following rough architecture picture gives an overview (not all available plugins are included):

Version vom 22. Juni 2023, 17:11 Uhr

expecco + expecco ALM = AIDYMO[Bearbeiten]

expecco is the component within the AIDYMO tool suite that is responsible for the development and execution of automation tasks and tests. expecco is a client-side application that runs on the user's development system or as a "test execution slave" in a server farm (possibly virtual) or in a Docker container.

expecco ALM is a server application with a web-browser interface and is responsible for the distribution of automation tasks among test slaves in a server farm. It cares for the reservation of test resources, avoids usage conflicts, for archival and revisioning of test suites, log files and test results, monitoring the project, notification of stakeholders etc. Expecco ALM will automatically distribute task among its available expecco "slaves", downloads suites to them, monitors progress and uploads results.

Both expecco and expecco ALM can be ordered and used as separate products or used together for a total automated system. However, as a team, these two provide a fully automated execution and quality infrastructure and are available together as AIDYMO.

expecco Base System (platform)[Bearbeiten]

expecco is a modular system, consisting of a basic platform and extensions ("plugins") that provide domain specific functions and interfaces.

The basic platform deals with:

  • loading and saving of test suites
  • creation, editing & maintenance of a test suite
  • execution
  • test development with single step, breakpoints and execution of partial sequences
  • test development with "live changes, while the system executes" (i.e. hotswap of code, short turn around times)
  • debugging both on high (diagram-) level and low (script/code-) level
  • seamless multi-language support for Java, Node.JS, Python, C/C++ and other languages
  • monitoring the execution, collecting execution traces and logs
  • collecting all data flows, message packages, intermediate results for later inspection
  • reporting, generating human- and machine readable reports in various formats.
  • interface to expecco ALM (up/download of suites, reports and logs)

Execution of a suite can be both under human supervision, or completely standalone and automated, without human interaction. The first mode is typically used during test development, the later when the test suite goes into production.

Automated unsupervised execution can be controlled by command line arguments or by RPC calls via SOAP or REST. Thus, test execution can be triggered by a cron job (Unix), scheduled tasks (Windows), Jenkins or any other program.

The basic platform contains:

  • expecco IDE
  • libraries (standard library, ODBC, XML and others)
  • Webtest: Browser automation (Selenium Webdriver, HTML5, Smart GWT,etc.)
  • manual tests (user guided test sequences)
  • ports: serial/USB/parallel
  • interfaces (DLL-calls, CSV, etc.)
  • webservices (REST, SOAP, RPC)
  • JavaBridge (to inject and/or execute Java code)
  • .NETBridge (to inject and/or execute DotNET code)
  • NodeJS Bridge (starting with v19.1) (to execute Node/Javascript code)
  • Python Bridge (v19.2) (to execute Python and Jython code)
  • C Bridge (v22.1) (to execute C/C++ code)
  • automatic reports
  • remote control (v23.1) (to control/monitor via browser, Android or IOS)

Plugins[Bearbeiten]

Extensions ("plugins") are available to test various UI-technologies, hard- and software interfaces, protocols and document formats. For example:

  • Mobile Testing Plugin for iPhone, Android, Windows CE, Windows-Phone Apps
  • GUI Test & Automation for Java-Swing, SWT and other UI frameworks
  • GUI Test & Automation for Windows Applications (using UIAutomation2)
  • GUI Test for Qt and other C/C++ based UI frameworks
  • GUI Test of VisualWorks applications
  • GUI Test for VNC connections
  • Interface to CAN bus systems (automotive)
  • Interface to SomeIP brokers/clients (automotive)
  • Interface to EDIFACT and SWIFT systems (B2B, finance)
  • Interface to MQTT and OPC systems (manufacturing, IoT, automotive)
  • Integration and execution of functional mockup units (FMU)
  • Import of test specifications (eg. from Excel- or Word documents)
  • Interfaces to specific lab equipment (telecom, automotive)

Plugins typically consist of additional dll- and block libraries that provide the domain specific functions as ready-to-use building blocks. These are inserted into test sequences via drag & drop. The GUI plugins include recording functions, so that user sessions are immediately available as an executable activity diagram.

Other plugins provide integration into the existing QM infrastructure:

  • Polarion Plugin to automate test execution under the Polarion ALM system
  • Quality Center Plugin to interface with HP-QC
  • Jira Plugin, to create issues in a Jira system
  • expecco ALM plugin to interface with our own QM/Test center

Availability[Bearbeiten]

Both expecco and expecco ALM are immediately available for Windows, Linux based systems in both 32bit and 64bit versions. A macOS version (64bit only) is in beta testing stage and will be available soon (currently upon request). Versions for Solaris and other Unix-based systems are available upon request.

Licensing[Bearbeiten]

expecco licenses are available as single user (node-lock or dongle), floating user (using a license manager) or company licenses. expecco can be used in isolated environments without access to a company network or the internet (using single-user or detached license server licenses). Please contact eXept for pricing and conditions.

Architecture[Bearbeiten]

In principle, expecco is a "black box" test system, which does not expect or require any instrumentation of the tested system (SUT = "System Under Test") (i.e. it is not necessary to extend the SUT with special code or link special libraries to it). However, it allows "code injection" for Java, .NET and Python applications, thus "grey box" and "white box" tests are also possible.

In expecco, test scenarios can be formulated on a high level of abstraction as (activity) diagrams, as "keyword-driven" test sequences or as textual scripts in various programming languages. Scripts can be executed in expecco itself as well as in the SUT or other machines (e.g. to stimulate the SUT or to generate load).

The following rough architecture picture gives an overview (not all available plugins are included):

expecco architecture (not all plugins shown)

(or as PDF: Datei:ExpeccoArchitecture1.pdf)

Konzept[Bearbeiten]

Die Grundphilosophie von Expecco ist, daß Testabläufe sowohl von Entwicklern und Programmierern, als auch von Domänenexperten und Analysten erstellt, gewartet und ausgeführt werden können, ohne daß dazu spezielle Programmierkenntnisse notwendig wären. Dabei darf es aber keine Einschränkungen geben, und ein erfahrener Nutzer hat alle Mittel zur Verfügung, um eigenen Code, Scripte und erweiterte Funktionen zu erstellen.

Um beiden Anforderungen gerecht zu werden, können Abläufe in Expecco sowohl als Aktivitätsdiagramm ("Kästchen und Pfeile") als auch als Scriptcode in verschiedenen Programmiersprachen definiert werden. Die ermöglicht einen "Best of both Worlds" Ansatz: einerseits können Nichtprogrammierer auf einer hohen Abstraktionsebene bestehende Aktionsbausteine mittels "Drag & Drop" oder Recording von GUI Aktionen zu komplexen Szenarien verbinden, andererseits ist es möglich, fehlende Funktionsbausteine als Scriptcode zu erstellen, und als Aktionsbaustein für andere Aktionen bereit zu stellen. Wobei "Scriptcode" hier für JavaScript, Python, Java, Shell/Batch bis hin zu C/C++ steht.

"Hardcore" Entwickler können selbstverständlich auch den gesamten Testablauf als Script/Programmcode definieren - allerdings geht dadurch u.U. die Verständlichkeit und modulare Nutzbarkeit für Nichtprogrammierer mehr oder weniger verloren. Wir raten daher im Allgemeinen dazu, Programmcode nur zu verwenden, um Anbindungen an bestehende Frameworks zu kapseln, und den eigentlichen Ablauf als Aktivitätsdiagramm zu formulieren.

In der Praxis wird es zu einer Aufgabenteilung kommen: für die Anbindung an das getestete System (SUT - System under Test) werden oft spezielle Aktionsbausteine benötigt, die ein Programmierer entwickeln wird (z.B. Anbindungen an Protokolle, Hardware oder Dokumentformate). Der Ablauf der Testszenarien wird dann gemeinsam von Entwicklern, Testern und Analysten durch Diagramme auf einer höheren Abstaktionsebene definiert, wobei hierzu kein Programmierknowhow benötigt wird.

Erweiterbar[Bearbeiten]

Eigene Aktionsbausteine können eine große Menge an frei verfügbarem und bereits existierenden Code nutzen. Somit können Anbindungen an Protokolle, Hardware oder Dokumentformate schnell und preisgünstig realisiert werden. Sie können interaktiv Codefragmente in ihre Szenarien einbinden, welche in JavaScript (Node.js/npm), Python, Java (jar-Dateien), DotNET (Assemblies), R (statistische Auswertungen), Gnuplot (Grafiken erstellen) u.a.m. erstellt wurden. Für diese Programmiersprachen gibt es eine große Menge an frei verfügbaren oder auch lizensierbaren Programmpaketen, z.B. in github oder als npm (Node.js) bzw. pip (Python) Pakete.



Copyright © 2014-2024 eXept Software AG