Introduction

Edited on March 14, 2017

Welcome to the stepdocs!

We hope you'll enjoy browsing our documentation. More content is added on a daily basis, but if you have any question, please use the communication means listed on our contact page at http://denkbar.io/contact/ . We'll be happy to answer them.

stepHomeSmall.png

Overview

step is a complete testing solution which allows its users to build test cases and execute them at scale. The primary benefit of using step lies in the fact that you'll be able to reuse each and every test fragment you develop for many different purposes and so you'll maximize your efficiency accross your different test practices.

The most frequent use cases we cover when we reuse these test fragements in step are :

  • continuous integration and batched unit testing
  • massive functional testing
  • integration & API testing
  • load and performance testing
  • synthetic monitoring
  • batch updates & generic job execution

Also, whenever you implement a test harness in step, you automatically and instantly get access to a number of core features which would otherwise be redundant in each individual tool you would use outside of step. Here's a non-comrehensive list of such features:

  • error tracking
  • performance measurements (reports + interactive & exploratory analysis)
  • test case input & output specification and validation semantics
  • load semantics
  • distribution and horizontal scaling accross a grid of agents
  • centralized web access to test artefacts and results
  • central scheduling

This unified approach makes a big difference in the way our users work, because it saves them a ton of time and it simplifies their workflows.

An other important aspect is the separation of concern that we introduced through the concept for "keywords", which are fine granular or "atomic" test fragments. Each keyword has its own business specification as far as inputs and output verification go and is eventually mapped to a concrete implementation (a script, a selenium class, a junit test, etc). For example, this approach allows functional testers to focus on specifying inputs and outputs and analyzing the results of the simulation, while technicians (developers / scripters) can focus on implementing the scripts. This concept also works for specifying and separating other roles around the platform: performance engineering, operational roles, etc.

Now let's move on to possibly the most important feature which you'll find in step, which is it's ability to integrate with many tools, especially simulation tools or engines. Step is pretty much a cameleon which allows you to work at the level you need :

  • API / Protocol
    with recording, for example with Grinder's TCPProxy for HTTP
  • User Event
    or user-action level, whether it's in a browser (any browser, with Selenium), or in a Java client (Swing or FX with Oryon or QFTest)
  • Graphical
    via image and text recognition (recording and replaying with Sikuli)
  • System
    we have a built-in process execution Keyword for invoking ANY OS-level runnable
  • Pure Java / Custom Code
    Example1 : unit test execution or any other deep-dive and complex code-based scenario.
    Example2 : testing complex client-side webservice code with the consumer's security context (full stack)

Last but not least, by installing step you're actually pretty much getting a scalable grid computing platform. Based on a controller-agent communication and backed by a mongoDB instance, the architecture of step allows for horizontal agent scalability. Current benchmarks show a max throughput of over 2300 test executions (keywords) per second on a single controller setup, while retaining all of the execution's metadata.