Testspace automatically discovers manual tests that are captured using “simple” plain text Markdown files and are committed to a repository. This approach follows the same process as software development - version control, pull requests for reviews, etc. The files are rendered as test instructions, allowing human testers to execute and provide status.

Optionally, for advanced implementation, a liquid template language can be used. This enables easier implementation of more complex functionality - variables, subroutines, and conditional logic are available, facilitating reuse and data-driven test cases.

There is also built-in support for calling remote serverless functions used for provisioning the state of the software under test. Users can implement tests that reduce manual execution time by automating tedious setups.

Implementing and executing manual tests includes:

  1. Leveraging Repository Functionality for test development
  2. Support for the Liquid Template Language
  3. Built-in Automated Fixturing functionality

Repository Functionality

Why is integrating with GitHub’s repositories so useful for manual testing? Traditional Test Management applications use proprietary user interfaces to capture the test case instructions. The test instructions thus become difficult to share and review with other team members, especially developers.

We have taken a different approach by using plain text files with support for the lightweight markup language called Markdown. These human-readable text files are stored and maintained in your repository. This model follows the developer workflow, enabling manual testing to supplement existing automated testing and facilitate developers participating in the manual test implementation “review” process.

This model includes source versioning, branching, and pull requests functionality supported by GitHub.

Thus, both automated and manual test files are stored in a repository.

Manual Tests Repo

The “Hello Manual” sample can be found here.


Use the GITHUB.DEV web-based editor for making changes that runs “entirely in your browser”. No console, no installation, just a great editor! Just press . while browsing your repository.

Manual Tests Repo Source

Testspace automatically discovers test files in a repository and renders them for human testers to execute and provide status.

Manual Tests Repo Spec

Testspace automatically discovers tests that are committed to a repository, rendering the files as manual test instructions.

Liquid Template Language

Testspace supports the template language called Liquid. Test files are handled as template files, meaning they get preprocessed before being rendered. This functionality enables a test file to use variables, include files (subroutines) along with passing parameters, and even the ability to implement conditional logic.

Liquid is an open-source template language created by Shopify. Jekyll, and GitHub pages, also support the Liquid template language. It is a simple yet comprehensive language that enables very powerful capability.

The following is an example of a metadata block (front-matter section) located at the top of the file. In this example, there is a list of OS systems.

title: OS Systems
matrix: # test different OS systems
  - name: Windows
    reqs: "[Windows details](https://staging7.newco.com/windows)"
  - name: Linux
    reqs: "[Linux details](https://staging7.newco.com/linus)"

# Example Test
blah blah ..

Within the test body a loop can be leveraged:

{% for os in spec.matrix %}
## Test  {{ os.name }}  
* check on requirements: {{ os.reqs }}
{% endfor %}

The following is a list of core functionality supported by Liquid:

The concept is to create powerful tests “without repeating yourself”.


Refer to the Desktop Preview documentation for reviewing tests on your desktop leveraging Jekyll.

Automated Fixturing

An automated test fixture is a serverless function that uses a GitHub Workflow or an AWS Lambda to host it. Automated fixtures could be run before and/or after the manual test instructions to setup/teardown a specific test environment.

Testspace supports integrating automation with manual testing. The following are some key benefits:

Testspace fixtures enable testing that leverages a hybrid of automation and manual verification.


The header block to define the fixture.

title: Setup database
  name: github::fixture
    a: one
    b: two

# Check DB
This test verifies state changes based on database content.

## Check One

## Check Two

The GitHub Action that gets invoked (.github/workflows/testspace.yml):

name: Testspace
        description: 'Function name'
        required: true
        description: 'Function input-payload'
        required: true
        description: 'Function execution-context'
        required: true
  IN_NAME:    ${{ inputs.name }}
  IN_PAYLOAD: ${{ inputs.payload }}
    if: github.event.inputs.name == 'fixture'
    runs-on: ubuntu-latest
      - uses: actions/checkout@v1
      - uses: actions/setup-node@v1
          node-version: '12'
      - name: Call Script implementing setup fixture
        run: node ./.github/workflows/handler.js 


The handler.js script (aka function) is invoked along with the passed parameters from the test file. This script does all of the specific fixturing.

Checkout the following:

Get setup in minutes!

Try Testspace risk-free. No credit card is required.

Have questions? Contact us.