Crate rust_slim

A (not yet complete) implementation of a SlimServer for acceptance testing.

This was implementating using the documentation found here

To add it to your project simply run:

cargo add rust_slim -F macros --dev

Then you need to create your fixtures. The recomended way of doing this is by using the #[fixture] macro. Here is an example:

use rust_slim::fixture;

#[derive(Default)]
pub struct Calculator {
    a: i64,
    b: i64,
}

#[fixture]
impl Calculator {
    pub fn set_a(&mut self, a: i64) {
        self.a = a
    }

    pub fn set_b(&mut self, b: i64) {
        self.b = b
    }

    pub fn sum(&self) -> i64 {
        self.a + self.b
    }

    pub fn mul(&self) -> i64 {
        self.a * self.b
    }

    pub fn sub(&self) -> i64 {
        self.a - self.b
    }

    pub fn div(&self) -> i64 {
        self.a / self.b
    }
}

All methods that are public will be able to be called by the slim server.

Than, we need to add an entrypoint to the slim server so we can run it. There are lot of ways of doing this. One is by creating an example in your project.

So create and example file called calculator.rs and add this:

use rust_slim::SlimServer;
use std::net::TcpListener;
use anyhow::Result;
use std::env::args;

fn main() -> Result<()> {
    let port = args().skip(1).next().unwrap_or("8085".to_string());
    let listener = TcpListener::bind(format!("0.0.0.0:{port}").to_string()).expect("Error");
    let (stream, _) = listener.accept()?;
    let mut server = SlimServer::new(stream.try_clone()?, stream);
    server.add_fixture::<Calculator>();
    server.run()?;
    Ok(())
}

Than, to run it, you simply call cargo run --example calculator. Now you need to configure your test runner (fitnesse, temoc) to call your server

Structs

SlimServer

The SlimServer responsible to get the Slim commands and execute against the Fixtures.

Enums

ExecuteMethodError

Error that can happen while trying to execute a method in a feature.

Traits

ClassPath

ClassPath that will be used in the construction of the fixture. It must be pascal case and have its parts separated by a .. Eg: Fixtures.Calculator The #[fixture] macro will automatically implement it for the type in the impl block. By default, the macro will get the current module path and add the fixutre type. For example, a fixutre with the type Calculator inside the module examples::calculator::fixtures will be converted to a path like Examples.Calculator.Fixtures.Calculator. You can use a custom path by passing it to the macro as such

Constructor

Trait used to construct the fixture. It is auto-implemented for fixtures that also implement Default.

SlimFixture

Fixtures must implement this trait to be able to be executed by the slim server. The #[fixture] macro will automatically implement it for the type in the impl block.

ToSlimResultString

Converts the result of a method into a result that the SlimServer can handle. This is mainly used so you can return whatever you want in a method and we can convert it inside the macro expansion of the [fixture] macro. If you are implementating the SlimFixture manually, you can ignore this. It has implementations for most basic types.

Functions

from_rust_module_path_to_class_path

Util function that convert a rust module path to the ClassPath used in Fitnesse.