Trait Verification 

pub trait Verification {
    // Required methods
    async fn verify(
        &self,
        pattern: &VerificationRequest,
        expected: VerificationCount,
    ) -> Result<VerificationResult, Error>;
    async fn verify_never(
        &self,
        pattern: &VerificationRequest,
    ) -> Result<VerificationResult, Error>;
    async fn verify_at_least(
        &self,
        pattern: &VerificationRequest,
        min: usize,
    ) -> Result<VerificationResult, Error>;
    async fn verify_sequence(
        &self,
        patterns: &[VerificationRequest],
    ) -> Result<VerificationResult, Error>;
}

Extension trait for verification methods on MockServer

Required Methods

async fn verify( &self, pattern: &VerificationRequest, expected: VerificationCount, ) -> Result<VerificationResult, Error>

Verify requests against a pattern and count assertion

Example

use mockforge_sdk::MockServer;
use mockforge_sdk::verification::Verification;
use mockforge_core::verification::{VerificationRequest, VerificationCount};

let mut server = MockServer::new().port(3000).start().await?;

// Make some requests...

let pattern = VerificationRequest {
    method: Some("GET".to_string()),
    path: Some("/api/users".to_string()),
    query_params: std::collections::HashMap::new(),
    headers: std::collections::HashMap::new(),
    body_pattern: None,
};

let result = server.verify(&pattern, VerificationCount::Exactly(3)).await?;
assert!(result.matched, "Expected GET /api/users to be called exactly 3 times");

async fn verify_never( &self, pattern: &VerificationRequest, ) -> Result<VerificationResult, Error>

Verify that a request was never made

Example

use mockforge_sdk::MockServer;
use mockforge_sdk::verification::Verification;
use mockforge_core::verification::VerificationRequest;

let mut server = MockServer::new().port(3000).start().await?;

// Make some requests...

let pattern = VerificationRequest {
    method: Some("DELETE".to_string()),
    path: Some("/api/users/1".to_string()),
    query_params: std::collections::HashMap::new(),
    headers: std::collections::HashMap::new(),
    body_pattern: None,
};

let result = server.verify_never(&pattern).await?;
assert!(result.matched, "Expected DELETE /api/users/1 to never be called");

async fn verify_at_least( &self, pattern: &VerificationRequest, min: usize, ) -> Result<VerificationResult, Error>

Verify that a request was made at least N times

Example

use mockforge_sdk::MockServer;
use mockforge_sdk::verification::Verification;
use mockforge_core::verification::VerificationRequest;

let mut server = MockServer::new().port(3000).start().await?;

// Make some requests...

let pattern = VerificationRequest {
    method: Some("POST".to_string()),
    path: Some("/api/orders".to_string()),
    query_params: std::collections::HashMap::new(),
    headers: std::collections::HashMap::new(),
    body_pattern: None,
};

let result = server.verify_at_least(&pattern, 2).await?;
assert!(result.matched, "Expected POST /api/orders to be called at least 2 times");

async fn verify_sequence( &self, patterns: &[VerificationRequest], ) -> Result<VerificationResult, Error>

Verify that requests occurred in a specific sequence

Example

use mockforge_sdk::MockServer;
use mockforge_sdk::verification::Verification;
use mockforge_core::verification::VerificationRequest;

let mut server = MockServer::new().port(3000).start().await?;

// Make some requests in sequence...

let patterns = vec![
    VerificationRequest {
        method: Some("POST".to_string()),
        path: Some("/api/users".to_string()),
        query_params: std::collections::HashMap::new(),
        headers: std::collections::HashMap::new(),
        body_pattern: None,
    },
    VerificationRequest {
        method: Some("GET".to_string()),
        path: Some("/api/users/1".to_string()),
        query_params: std::collections::HashMap::new(),
        headers: std::collections::HashMap::new(),
        body_pattern: None,
    },
];

let result = server.verify_sequence(&patterns).await?;
assert!(result.matched, "Expected requests to occur in sequence");

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Verification for MockServer