Introduction to FitNesse – An Acceptance Testing Framework

1. Overview

While unit and integration tests help developers verify that an application behaves as expected, they typically require programming knowledge to write and maintain. Acceptance tests, on the other hand, allow testers to verify an application’s behavior against its requirements without writing test code.

FitNesse is a popular acceptance testing framework for Java applications.

In this tutorial, we’ll see how to use FitNesse to write an acceptance test for a simple banking application.

2. Understanding the FitNesse Framework

FitNesse is an acceptance testing framework that can be used with Java applications. It provides a web-based wiki interface where we can create, edit, and run acceptance tests without writing them in a traditional programming language. FitNesse uses its own wiki-style syntax rather than standard Markdown.

Furthermore, it supports two test systems: Fit and Slim. Slim is a commonly used option in modern FitNesse tests. With Slim, FitNesse communicates with fixture code through the Slim protocol, allowing our Java code to be invoked as part of an acceptance test.

To use FitNesse, we can download its executable JAR and run it as a Java application. Alternatively, we can add FitNesse as a test dependency to a Maven or Gradle project when we want to manage it as part of the project’s build configuration.

3. Maven Dependency

Moving on, let’s add the fitnesse dependency to our pom.xml:

<dependency>
    <groupId>org.fitnesse</groupId>
    <artifactId>fitnesse</artifactId>
    <version>20260313</version>
    <scope>provided</scope>
</dependency>

The fitnesse dependency includes the FitNesse application and its embedded web server. Once we start FitNesse, it exposes a web interface that we can access from a browser to create and run acceptance tests.

4. Example Project

To demonstrate how it works, let’s create a simple banking application.

4.1. BankAccount Class

First, let’s create a class named BankAccount:

public class BankAccount {

    private double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    public void deposit(double amount) {
        balance += amount;
    }

    public void withdraw(double amount) {
        balance -= amount;
    }

    public double getBalance() {
        return balance;
    }
}

In the class above, we initialize the account with a balance provided through the constructor. Then, we define methods for depositing money, withdrawing money, and retrieving the current balance. For simplicity, we used the double type to represent monetary value.

4.2. BankAccountFixture Class

Next, let’s create a fixture class that exposes the banking operations to FitNesse:

public class BankAccountFixture {
    private BankAccount account;
    private double depositAmount;
    private double withdrawAmount;

    public void setInitialBalance(double balance) {
        account = new BankAccount(balance);
    }

    public void setDeposit(double amount) {   
        this.depositAmount = amount;
    }

    public void setWithdraw(double amount) {
        this.withdrawAmount = amount;
    }

    public void execute() {          
        if (depositAmount > 0) {
            account.deposit(depositAmount);
        }
        if (withdrawAmount > 0) {
            account.withdraw(withdrawAmount);
        }
    }

    public double balance() {
        return account.getBalance();
    }
}

The class above acts as a bridge between FitNesse and our BankAccount class. It exposes methods that FitNesse can invoke as part of an acceptance test.

The setInitialBalance(), setDeposit(), and setWithdraw() methods configure the test data, while execute() performs the requested operations on the account. Finally, the balance() method returns the resulting balance.

These operations represent the behavior that we want to verify through our acceptance tests.

5. Writing an Acceptance Test

To begin, let’s create a launcher class with a main() method to start the FitNesse server:

public class FitNesseLauncher {

    public static void main(String[] args) throws Exception {
        FitNesseMain.main(new String[] { "-p", "8080" });
    }
}

Next, let’s run the main() method and open the landing page by visiting it in our browser:

Here’s the default FitNesse landing page. Since we don’t need the default content for our example, let’s edit the page by clicking Edit and create our acceptance test:

Here, we delete the original content of the page and add our test. First, we configure FitNesse to use the Slim test system. Next, we add the directory containing our compiled Java classes to the FitNesse classpath. Then, we import the package containing our fixture.

Finally, we define the acceptance test using FitNesse’s wiki table syntax.

After clicking the Save button, here’s the new page:

The saved page now displays our acceptance test. However, the Test button isn’t enabled yet. Let’s configure the page properties to enable test execution.

To do this, let’s click on Tools and select Properties:

The page properties have different options. Under the Page type, let’s select Test and click the Save Properties button. After saving the properties, the Test button becomes available on the test page.

Next, let’s click Test to execute the acceptance test:

The test results show that all five assertions passed successfully, with 0 wrong assertions, 0 ignored assertions, and 0 exceptions. The resulting balances also match the expected values in each test case.

6. Conclusion

In this lesson, we learned how to use FitNesse to write and execute acceptance tests for a Java application. Also, we built a simple banking application and created a Slim fixture that allowed FitNesse to interact with the application’s business logic.

Additionally, we saw how to configure and start the FitNesse server, configure FitNesse to use the Slim test system, and add compiled Java classes to the FitNesse classpath.

As always, the source code for the examples is available over on GitHub.