rfs_test_macro 1.1.3

This package provides macro to simplify usage of rfs_tester crate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

# rfs_test_macro

[![Crates.io](https://img.shields.io/crates/v/rfs_test_macro)](https://crates.io/crates/rfs_test_macro)
[![License](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue)](https://crates.io/crates/rfs_test_macro)

`rfs_test_macro` is a attribute macro designed to simplify the configuration of test units for the [`rfs_tester`](https://crates.io/crates/rfs_tester) crate since v0.3.1. It provides an easy-to-use interface for setting up and managing filesystem tests.

## Overview

The `rfs_tester` crate creates a temporary directory for running filesystem tests and automatically cleans it up after the tests are completed. The `rfs_test_macro` crate provides a macro that simplifies the process of configuring and running these tests.

## Usage

Add `rfs_test_macro` to your `Cargo.toml`:

```toml
[dev-dependencies]
rfs_test_macro = "1.1.3"
```

Then, use the macro in your test files when temp dir should create in current folder:

```rust
const CONFIG: &str = r#"---
    - !directory
        name: test
        content:
            - !link
                name: file_link.txt
                target: LICENSE-MIT
"#;

#[rfs_test(config = CONFIG)]
fn link_creation_test(dirname: &str) -> std::io::Result<()> {
    let link_path = format!("{dirname}/file_link.txt");
    let meta = fs::metadata(link_path)?;
    assert!(meta.is_symlink());
    Ok(())
}
```

Or when you want to place temp folder in another path you can set start_point parameter

```rust
...
#[rfs_test(config = CONFIG, start_point = "/tmp")]
fn link_creation_test(dirname: &str) -> std::io::Result<()> {
...
```

You can specify config inline:

```rust
#[rfs_test(
    config = r#"---
    - !directory
        name: test
        content:
          - !file
              name: test.txt
              content:
                !inline_text "Hello, world!"
    "#
)]
fn file_creation_test_with_macro(dirname: &str) -> std::io::Result<()> {
    let file_path = format!("{}/test.txt", dirname);
    let content = std::fs::read_to_string(file_path)?;
    assert_eq!(content, "Hello, world!");
    Ok(())
}
```

The macro will handle the setup and teardown of the temporary directory, allowing you to focus on writing your test logic.

## Features

* Easy Configuration: Simplifies the setup of filesystem tests.

* Automatic Cleanup: Ensures that temporary directories are removed after tests complete.

* Seamless Integration: Works seamlessly with the rfs_tester crate.

## License

This project is licensed under either of the following licenses:

* MIT License (LICENSE-MIT)

* Apache License, Version 2.0 (LICENSE-APACHE)

at your option.

## Contributing

Contributions are welcome! If you'd like to contribute, please open an issue or submit a pull request.