Was ist expecco?/en
Inhaltsverzeichnis
Overview[Bearbeiten]
expecco and expecco ALM[Bearbeiten]
expecco is the component within the expecco tool chain which serves the development and the performance of tests. expecco is a "native client" application which either runs on the computer of the test developer or the testers or as a "test execution slave" in a (possibly virtualized) server farm or was installed in a docker container. With expecco test plans are defined and executed.
expecco ALM is a server application with browser interface which ensures distribution and correct execution of the tests within the server farm, manages test resources and avoids utilization conflicts, archives and modifies test suites and results, observes and reports the project of the progress, sends out notifications etc. With "expecco ALM" test runs are brought automatically in "test execution servant" in local network or in a cloud environment and the results are being archived.
Both expecco and expecco ALM are independent products which can be ordered separately, installed and applied, however in combination they implement a fully automated test execution and quality control.
expecco Basic System (Platform)[Bearbeiten]
expecco is a modular system which consists of a basic platform as well as extensions ("plugins"). Plugins implement domain-specific functions and connections.
The base system contains:
- Loading and saving of von Test suites
- The creating, editing and maintenance of test suites
- Test execution
- Test development with Singlestep, Breakpoints, execution of partial sequences
- Test development with "Live changes while the system runs"
- Debugging on higher (diagram-) as well as on lower (script/code) level
- Monitoring of execution, collecting of trace-, time- and log data
- Collecting of all data flows, news packages and intermediate results for a later inspection
- Generating reports as human readable documents in different formats
The test execution can both take place under the charge and control of one operator as well as completely unobserved. The first will be typically the case during the test development, latter in the production environment, when the test will come automatically in the process.
The automated execution can be initiated or controlled from the command line or from remote computers via SOAP or REST. Thus the test execution can be initiated automatically by cron-Job (unix), scheduled tasks, Jenkins or any other program.
The basic system contains:
- expecco IDE
- Libraries (Standard, ODBC, XML)
- Webtest: Selenium (Webdriver, HTML5, Smart GWT,etc.)
- Manual tests (User-guided procedure)
- Ports: serial/USB/parallel
- Connections (DLL, CSV, etc.)
- Webservices (REST, SOAP, RPC)
- JavaBridge (execute Java Code as well as Code Injection in Java Program)
- NETBridge (execution of DotNET Code)
- NodeJS Bridge from 19.1 (seamless Node/Javascript Code execution)
- Python Bridge from 19.1 (seamless Python Code execution)
Plugins[Bearbeiten]
Extensions ("plugins") realize the interfaces to various UI technologies, to hardware and software interfaces, protocols and document formats. Some of these plug-ins are included in the basic system or can be ordered as required.
For example:
- Mobile Testing Plugin for Apps under iOS and Android
- GUI testing for Java Swing, SWT and other Java UI frameworks
- GUI testing for Qt and other C/C++ based UI frameworks
- GUI Testing for Windows Applications (Windows Automation)
- GUI testing via VNC
- Webtest with Selenium for Firefox, IE, Safari, Opera and Chrome browsers
- Interfaces to CAN bus systems like CANoe (Automotive)
- Interfaces to SomeIP Brokers / Clients (Automotive)
- Interfaces to EDIFACT and SWIFT systems (B2B, Finance)
- Interfaces to MQTT and OPC systems (Manufacturing, Internet of Things, Automotive)
Typically, plugins consist of additional dll and block libraries that contain domain-specific functions as ready-to-use building blocks. These are then inserted into the test sequences with drag & drop.
Other plugins are used for integration into an existing QM infrastructure:
- Polarion Plugin to assemble tests in the Polarion ALM system and automate them with expecco
- Quality Center Plugin as interface to HP-QC
- Jira Plugin to automatically create or update Jira Issues after test runs
- expecco ALM Plugin as interface to our own QM/Testcenter product
Availability[Bearbeiten]
expecco and expecco ALM are available for Windows and Linux systems, both as 32bit and 64bit versions. A version for macOS (64bit) is in beta testing and available on request. Versions for Solaris and other Unix systems can also be provided on request.
Licensing[Bearbeiten]
Licenses for expecco are available as single user, floating (using a license manager/license server) or company license. expecco can be used (using single user or license triggered by the license server) in isolated environments, without access to the company network or Internet. For prices and conditions please contact eXept.
Architecture[Bearbeiten]
expecco has a modular structure and consists of a domain-independent basic system, which includes the editor, executor and reporting, as well as plug-ins and extensions, which realize domain-specific connections to various systems, protocols, hardware interfaces and document formats.
In principle expecco is a "Black Box" test system, which does not expect or need any instrumentation of the tested system (SUT = "System Under Test") (i.e. it is not necessary to extend the SUT with special code or to bind special libraries to it). However, it allows "code injection" in Java and .NET applications, whereby "Grey Box" and "White Box" tests are also supported.
Test scenarios can be formulated in expecco on a high abstraction level as (activity) diagrams, as keyword-driven test sequences or as textual scripts in different 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 architectural picture gives an overview (not all available plugins are included):
(oder als 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 means at his disposal to create his own code, scripts and extended functions.
In order to meet both requirements, Expecco's processes can be defined both as activity diagrams ("boxes and arrows") and as script code in different programming languages. This enables a "Best of both Worlds" approach: on the one hand, non-programmers can connect existing action modules on a high abstraction level to complex scenarios using "Drag & Drop", 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.
"Hardcore" developers can, of course, also define the entire test sequence as a script - however, the natural comprehensibility for non-programmers is more or less lost. 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 test scenario flow is then defined jointly by developers and analysts using diagrams at a higher abstraction level. Extensible
Extendable[Bearbeiten]
Own action blocks can use a large amount of freely available and already existing code. This means that connections to protocols, hardware or document formats can be implemented quickly and inexpensively. You can interactively integrate code fragments into your scenarios, which have been created in JavaScript (Node/npm), Python, Java (jar files), DotNET (Assemblies), R (Statistical Analyses), Gnuplot (Create Graphics) and many more.
