Expecco Overview/en
Inhaltsverzeichnis
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):
(or as PDF: Datei:ExpeccoArchitecture1.pdf)
Concept[Bearbeiten]
The basic philosophy of Expecco is that test procedures can be created, maintained and executed by developers and programmers as well as by domain experts and analysts. without the need for special programming knowledge. However, there must be no restrictions, and an experienced user has all the means at his disposal to create his own code, scripts and advanced functions.
In order to meet both requirements, processes in Expecco can be defined both as activity diagrams ("boxes and arrows") and as script code in various programming languages. This enables a "Best of both worlds" approach: on the one hand, non-programmers can connect existing action modules to complex scenarios at a high level of abstraction using "Drag & Drop" or recording of GUI actions, on the other hand, it is possible to create missing function modules as script code and make them available as action modules for other actions. Where "script code" stands for JavaScript, Python, Java, Shell/Batch up to C/C++.
"Hardcore" developers can of course also define the entire test procedure as a script/program code - however, this may result in the comprehensibility and modular usability being more or less lost for non-programmers. We therefore generally advise only using program code to encapsulate connections to existing frameworks and formulating the actual process as an activity diagram.
In practice, there will be a division of tasks: for the connection to the tested system (SUT - System under Test), special action modules are often required, which a programmer will develop (e.g. connections to protocols, hardware or document formats). The flow of the test scenarios is then defined jointly by developers, testers and analysts using diagrams at a higher abstraction level, with no programming know-how being required for this.
Expandability[Bearbeiten]
Custom action modules can use a large amount of freely available and already existing code. In this way, connections to protocols, hardware or document formats can be implemented quickly and at low cost. You can interactively integrate code fragments into your scenarios, which are written in JavaScript (Node.js/npm), Python, Java (jar files), C/C++, DotNET (assemblies), R (statistical evaluations), Gnuplot (create graphics) and many more.
