blueprint-tangle-testing-utils 0.1.0-alpha.21

Tangle-specific testing utilities for Tangle Blueprints
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use crate::Error;
use crate::TangleTestHarness;
use blueprint_client_tangle::EventsClient;
use blueprint_core_testing_utils::setup_log;
use tangle_subxt::subxt::tx::Signer;

#[tokio::test]
async fn test_client_initialization() -> Result<(), Error> {
    setup_log();

    let temp_dir = tempfile::TempDir::new()?;
    let harness = Box::pin(TangleTestHarness::<()>::setup(temp_dir)).await?;

    assert!(
        harness
            .client()
            .subxt_client()
            .blocks()
            .at_latest()
            .await
            .is_ok(),
        "Client should be connected"
    );

    Ok(())
}

#[tokio::test]
async fn test_operator_metadata() -> Result<(), Error> {
    setup_log();

    let temp_dir = tempfile::TempDir::new()?;
    let harness = Box::pin(TangleTestHarness::<()>::setup(temp_dir)).await?;

    // Get operator metadata for the test account
    let metadata = harness
        .client()
        .operator_metadata(harness.sr25519_signer.account_id().clone())
        .await
        .unwrap();
    assert!(
        metadata.is_none(),
        "New account should not have operator metadata"
    );

    Ok(())
}

#[tokio::test]
async fn test_services_client() -> Result<(), Error> {
    setup_log();

    let temp_dir = tempfile::TempDir::new()?;
    let harness = Box::pin(TangleTestHarness::<()>::setup(temp_dir)).await?;
    let services = harness.client().services_client();

    // Test blueprint queries
    let block_hash = harness
        .client()
        .now()
        .await
        .expect("Should get current block hash");

    // Query non-existent blueprint
    let blueprint = services
        .get_blueprint_by_id(block_hash, 999_999)
        .await
        .unwrap();
    assert!(
        blueprint.is_none(),
        "Non-existent blueprint should return None"
    );

    // Query operator blueprints
    let blueprints = services
        .query_operator_blueprints(block_hash, harness.sr25519_signer.account_id().clone())
        .await
        .unwrap_or_default();
    assert!(
        blueprints.is_empty(),
        "New operator should have no blueprints"
    );

    Ok(())
}

#[tokio::test]
async fn test_events_client() -> Result<(), Error> {
    setup_log();

    let temp_dir = tempfile::TempDir::new()?;
    let harness = Box::pin(TangleTestHarness::<()>::setup(temp_dir)).await?;

    // Test event subscription
    let latest = harness.client().latest_event().await;
    assert!(latest.is_some(), "Should have access to latest event");

    // Test event stream
    let event = harness.client().next_event().await;
    assert!(event.is_some(), "Should be able to get next event");

    if let Some(event) = event {
        assert!(event.number > 0, "Block number should be positive");
        assert_ne!(event.hash, [0u8; 32], "Block hash should not be zero");
    }

    Ok(())
}

#[tokio::test]
async fn test_service_operators() -> Result<(), Error> {
    setup_log();

    let temp_dir = tempfile::TempDir::new()?;
    let harness = Box::pin(TangleTestHarness::<()>::setup(temp_dir)).await?;
    let services = harness.client().services_client();

    // Get current block hash
    let block_hash = harness
        .client()
        .now()
        .await
        .expect("Should get current block hash");

    // Query service operators for a non-existent service
    let operators = services
        .current_service_operators(block_hash, 999_999)
        .await
        .unwrap();
    assert!(
        operators.is_empty(),
        "Non-existent service should have no operators"
    );

    Ok(())
}