arch_testing 0.1.0

# Arch Testing

A comprehensive testing framework for Arch Network applications that provides containerized test environments for integration testing.

## Features

- **Containerized Test Environments**: Spin up isolated test environments using Docker containers
- **Bitcoin Integration**: Test with a local Bitcoin node for blockchain interactions
- **Arch Network Support**: Built-in support for Arch Network validators and programs
- **Titan Integration**: Test with Titan services for enhanced functionality
- **Async/Await Support**: Full async support with Tokio runtime
- **Configurable**: Flexible configuration options for different test scenarios

## Installation

Add this to your `Cargo.toml`:

```toml
[dependencies]
arch_testing = "0.1.0"
```

## Quick Start

```rust
use arch_testing::*;
use tokio;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize test context
    let test_context = TestContext::new().await?;
    
    // Start a Bitcoin container
    let bitcoin_config = BitcoinContainerConfig::default();
    let bitcoin_container = BitcoinContainer::new(bitcoin_config).await?;
    
    // Start a local validator
    let validator_config = LocalValidatorContainerConfig::default();
    let validator = LocalValidatorContainer::new(validator_config).await?;
    
    // Your test logic here
    println!("Test environment ready!");
    
    Ok(())
}
```

## Components

### BitcoinContainer

Test with a local Bitcoin node:

```rust
use arch_testing::{BitcoinContainer, BitcoinContainerConfig};

let config = BitcoinContainerConfig {
    rpc_port: Some(18443),
    p2p_port: Some(18444),
    ..Default::default()
};

let bitcoin = BitcoinContainer::new(config).await?;
// Use bitcoin.rpc_client() for Bitcoin RPC calls
```

### LocalValidatorContainer

Test with a local Arch Network validator:

```rust
use arch_testing::{LocalValidatorContainer, LocalValidatorContainerConfig};

let config = LocalValidatorContainerConfig::default();
let validator = LocalValidatorContainer::new(config).await?;
// Validator is ready for testing
```

### TitanContainer

Test with Titan services:

```rust
use arch_testing::{TitanContainer, TitanContainerConfig};

let config = TitanContainerConfig::default();
let titan = TitanContainer::new(config).await?;
// Titan services are available
```

## Configuration

All containers support flexible configuration through their respective config structs:

- `BitcoinContainerConfig`: Configure Bitcoin node settings, ports, and RPC credentials
- `LocalValidatorContainerConfig`: Configure validator settings and network parameters
- `TitanContainerConfig`: Configure Titan service settings

## Test Context

The `TestContext` provides a centralized way to manage your test environment:

```rust
use arch_testing::TestContext;

let context = TestContext::new().await?;
// Context manages the lifecycle of all containers
```

## Requirements

- Docker (for containerized test environments)
- Rust 1.70+ (2021 edition)
- Tokio runtime

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## Repository

[GitHub Repository](https://github.com/levicook/arch-testing)