trait-kit 0.1.0

Module Standard Interface and Capability Management Center — A lightweight Rust library that provides a standard interface for module definition and Kit capability management.
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

// Copyright © 2026 Kirky.X. All rights reserved.

//! Kit capability store tests (TC-KIT-001~007).

mod common;

use std::sync::Arc;

use trait_kit::prelude::*;

use common::*;

#[test]
fn tc_kit_001_provide_first_registration() {
    let kit = Kit::new();
    let logger: Arc<dyn Logger + Send + Sync> = Arc::new(TestLogger {
        prefix: "[test] ".to_string(),
    });

    let result = kit.provide::<MainLogger>(logger.clone());
    assert!(result.is_ok());
    assert!(kit.contains::<MainLogger>());
    assert!(Arc::ptr_eq(&kit.require::<MainLogger>().unwrap(), &logger));
}

#[test]
fn tc_kit_002_provide_duplicate_fails() {
    let kit = Kit::new();
    let logger_1: Arc<dyn Logger + Send + Sync> = Arc::new(TestLogger {
        prefix: "[v1] ".to_string(),
    });
    let logger_2: Arc<dyn Logger + Send + Sync> = Arc::new(TestLogger {
        prefix: "[v2] ".to_string(),
    });

    kit.provide::<MainLogger>(logger_1.clone()).unwrap();
    let result = kit.provide::<MainLogger>(logger_2);

    assert!(matches!(
        result,
        Err(KitError::DuplicateCapability { key: "main_logger" })
    ));
    assert!(Arc::ptr_eq(
        &kit.require::<MainLogger>().unwrap(),
        &logger_1
    ));
}

#[test]
fn tc_kit_003_replace_overwrites_existing() {
    let kit = Kit::new();
    let logger_1: Arc<dyn Logger + Send + Sync> = Arc::new(TestLogger {
        prefix: "[v1] ".to_string(),
    });
    let logger_2: Arc<dyn Logger + Send + Sync> = Arc::new(TestLogger {
        prefix: "[v2] ".to_string(),
    });

    kit.provide::<MainLogger>(logger_1).unwrap();
    kit.replace::<MainLogger>(logger_2.clone());

    assert!(Arc::ptr_eq(
        &kit.require::<MainLogger>().unwrap(),
        &logger_2
    ));
}

#[test]
fn tc_kit_004_replace_works_without_existing() {
    let kit = Kit::new();
    let logger: Arc<dyn Logger + Send + Sync> = Arc::new(TestLogger {
        prefix: "[test] ".to_string(),
    });

    kit.replace::<MainLogger>(logger.clone());

    assert!(kit.contains::<MainLogger>());
    assert!(Arc::ptr_eq(&kit.require::<MainLogger>().unwrap(), &logger));
}

#[test]
fn tc_kit_005_require_returns_registered() {
    let kit = Kit::new();
    let logger: Arc<dyn Logger + Send + Sync> = Arc::new(TestLogger {
        prefix: "[test] ".to_string(),
    });

    kit.provide::<MainLogger>(logger.clone()).unwrap();
    let result = kit.require::<MainLogger>();

    assert!(result.is_ok());
    assert!(Arc::ptr_eq(&result.unwrap(), &logger));
}

#[test]
fn tc_kit_006_require_missing_fails() {
    let kit = Kit::new();
    let result = kit.require::<MainLogger>();

    assert!(matches!(
        result,
        Err(KitError::MissingCapability { key: "main_logger" })
    ));
}

#[test]
fn tc_kit_007_contains_missing_returns_false() {
    let kit = Kit::new();
    assert!(!kit.contains::<MainLogger>());

    assert!(matches!(
        kit.require::<MainLogger>(),
        Err(KitError::MissingCapability { key: "main_logger" })
    ));
}