Squash TM: Open-Source Test Management for Agile Teams

Squash TM is an open-source test management tool developed by Henix. It provides requirement traceability, test case management, test campaigns, and automation integration — the core features of commercial tools like TestRail and Zephyr — under an open-source license.

For teams that need structured test management without per-user licensing costs, Squash TM is a serious option.

What Squash TM Does

Squash TM organizes testing around four core concepts:

Requirements: User stories, functional requirements, or acceptance criteria. Requirements are the "what" — what the system must do.

Test Cases: Specific test procedures that verify requirements. Test cases are the "how" — how you verify the system does what it should.

Test Campaigns: Groups of test cases organized for a specific testing effort — a sprint, a release, a regression cycle. A campaign contains test suites, which contain test cases assigned to specific testers.

Defects: Bugs found during test execution. Squash TM integrates with Jira, Bugzilla, and Mantis for defect tracking.

The key value is traceability: you can see which requirements are covered by which test cases, and which test campaign results confirm which requirements.

Installation

Squash TM runs as a Java web application. The easiest installation is Docker:

# docker-compose.yml for Squash TM
version: '3'
services:
  squash-tm:
    image: squashtest/squash-tm
    ports:
      - "8080:8080"
    environment:
      SQUASH_TM_DB_TYPE: h2  # Use PostgreSQL for production
    volumes:
      - squash-data:/squash-tm/data
  
volumes:
  squash-data:

docker-compose up -d
# Access at http://localhost:8080
# Default credentials: admin / admin (change immediately)

For production, use PostgreSQL:

environment:
  SQUASH_TM_DB_TYPE: postgresql
  SQUASH_TM_DB_URL: jdbc:postgresql://postgres:5432/squashtm
  SQUASH_TM_DB_USERNAME: squash
  SQUASH_TM_DB_PASSWORD: yourpassword

Project Structure

Squash TM organizes work into projects. Create a project for each application or major product area:

1. Go to Administration > Projects > New Project
2. Name: My Application
3. Set permissions: who can view, create tests, execute, manage

Within a project:

• Requirements workspace: Manage requirements and user stories
• Test Cases workspace: Write and organize test cases
• Campaigns workspace: Create test campaigns and track execution
• Bugtracker link: Configure Jira/Bugzilla integration

Writing Requirements

Add requirements that tests will verify:

1. Open the Requirements workspace
2. Create a folder structure: Authentication, User Profile, Billing
3. Create a requirement: User can log in with valid email and password
4. Add properties:
   • Reference: REQ-AUTH-001
   • Criticality: Critical
   • Status: In Progress
   • Description: Full acceptance criteria text

Requirements can be imported from Excel or synchronized from Jira if you manage requirements there.

Writing Test Cases

In the Test Cases workspace:

1. Create a folder matching your requirements structure
2. Create a test case: Login with valid credentials
3. Add steps:

Step 1: Navigate to login page
   Action: Open browser and go to https://app.example.com/login
   Expected: Login form displays with email and password fields

Step 2: Enter valid credentials
   Action: Enter test@example.com in email field, TestPass123! in password field
   Expected: Both fields accept input without validation errors

Step 3: Submit form
   Action: Click "Sign In" button
   Expected: Form submits, loading indicator appears

Step 4: Verify successful login
   Action: Wait for redirect
   Expected: Dashboard URL loaded, user name visible in header

Step 5: Verify session
   Action: Refresh page
   Expected: User remains logged in, dashboard still visible

4. Link to requirements: In the test case, go to "Requirements covered" > search for REQ-AUTH-001 > link it

This creates the traceability: requirement → test case(s) that verify it.

Creating a Test Campaign

A campaign represents a testing effort:

1. Go to Campaigns workspace > New Campaign
2. Name: Sprint 24 Regression
3. Set dates: start/end
4. Create a Test Suite inside the campaign: Authentication Tests
5. Add test cases to the suite by dragging from the Test Cases workspace
6. Assign test cases to testers: each test case can be assigned to a specific team member

Executing Tests

When running a campaign:

1. Open the campaign
2. Click on a test case assigned to you
3. Execute step by step:
   • Mark each step as: Pass, Fail, or Blocked
   • Add comments on failure
   • Attach screenshots
4. Mark the overall test case as: Success, Failure, or Blocked
5. If a step fails, log a defect in the linked bugtracker

The campaign dashboard shows real-time progress: how many test cases are complete, passing, failing, blocked.

Automation Integration

Squash TM's automation integration (Squash TA) connects manual test cases to automated test scripts. You write automated tests in Robot Framework, Cucumber, or JUnit, then link them to Squash TM test cases.

When the CI pipeline runs the automated tests, results are pushed back to Squash TM and displayed in the campaign dashboard alongside manual test results.

Configure automation in the Squash TM test case:

1. Open a test case
2. Go to "Automation" tab
3. Set Script Language: Robot Framework
4. Script path: tests/authentication/test_login.robot

In your CI pipeline:

- name: Run automated tests and report to Squash TM
  run: |
    robot --listener squashtm.listener:http://squash-tm:8080 \
          tests/

The listener pushes results to Squash TM automatically.

Squash TM vs. TestRail

The main TestRail advantage is UX polish and commercial support. Squash TM's advantage is cost and built-in requirements traceability. For teams in regulated industries where requirement-to-test traceability is mandatory for compliance (ISO 26262, DO-178C, FDA), Squash TM's native traceability model is compelling.

Squash TM Limitations

UI is dated: The interface is functional but not modern. TestRail and Zephyr feel significantly more polished.

Setup requires ops work: Self-hosting means you manage backups, upgrades, and infrastructure. Docker simplifies this but doesn't eliminate it.

Automation setup is complex: Squash TA configuration and the listener setup add complexity compared to simply pushing JUnit XML results to a cloud tool.

Performance: Large test suites (10,000+ test cases) can make the UI sluggish.

Summary

Squash TM is a capable open-source test management tool that handles requirements traceability, test case management, and campaign tracking without per-user licensing fees. The setup overhead and dated UI are real costs. For small teams or budget-constrained organizations that need structured test management, it's a solid choice. For teams that prioritize UX, cloud hosting, and commercial support, TestRail or Zephyr may be worth the licensing cost.