Setting up a Cargo workspace is the cleanest way to manage both your aggregator library and the aggregator_app binary in one place.

Ⅰ. Setting Up a Cargo workspace

1. Create a new workspace folder

Make a parent folder (say aggregator_workspace):

mkdir aggregator_workspace
cd aggregator_workspace

2. Create the workspace manifest

Inside it, create a Cargo.toml file:

[workspace]
members = [
    "aggregator",
    "aggregator_app",
]

This tells Cargo that both crates are part of one workspace.

3. Add your crates

Now create the two crates inside the workspace:

cargo new aggregator --lib
cargo new aggregator_app

Now the folder structure looks like this:

aggregator_workspace
├── Cargo.toml      # Workspace manifest
├── aggregator      # Library crate
│   ├── Cargo.toml
│   └── src/lib.rs
└── aggregator_app  # Binary crate
    ├── Cargo.toml
    └── src/main.rs

4. Define the library

Edit aggregator/src/lib.rs:

pub fn summarize(text: &str) -> String {
    format!("Summary: {}", text)
}

5. Link the binary to the library

In aggregator_app/Cargo.toml, add the dependency:

[dependencies]
aggregator = { path = "../aggregator" }

6. Use it in the binary

Edit aggregator_app/src/main.rs:

use aggregator::summarize;

fn main() {
    let text = "Rust makes systems programming fun and safe!";
    let summary = summarize(text);
    println!("{}", summary);
}

7. Build and run

From the workspace root:

cargo run -p aggregator_app

Output:

Summary: Rust makes systems programming fun and safe!

✅ Now you have:

aggregator → library crate
aggregator_app → binary crate
managed together in one workspace.

Ⅱ. How to Test the Library

Let’s extend the workspace so you can test your aggregator library while also running the app. There are two ways to test library, one is adding tests inside the library and the other is adding separate integration tests in a tests/ directory

1. Add tests inside the library

Edit aggregator/src/lib.rs:

/// Summarize a given text by prefixing it.
pub fn summarize(text: &str) -> String {
    format!("Summary: {}", text)
}

// Unit tests go in a special `tests` module.
#[cfg(test)]
mod tests {
    // Bring outer functions into scope
    use super::*;

    #[test]
    fn test_summarize_simple() {
        let text = "Hello Rust";
        let result = summarize(text);
        assert_eq!(result, "Summary: Hello Rust");
    }

    #[test]
    fn test_summarize_empty() {
        let text = "";
        let result = summarize(text);
        assert_eq!(result, "Summary: ");
    }
}

2. Run the tests

From the workspace root:

cargo test -p aggregator

Output (example):

running 2 tests
test tests::test_summarize_simple ... ok
test tests::test_summarize_empty ... ok

test result: ok. 2 passed; 0 failed

3. Run the app

From the same root:

cargo run -p aggregator_app