dynpatch-core 0.1.0

Runtime engine for dynpatch - dynamic library loading, ABI validation, and transactional patching
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

//! Integration tests for dynpatch-core

use dynpatch_core::{PatchRegistry, Validator, ValidationConfig};
use dynpatch_interface::{PatchMetadata, Version};

#[test]
fn test_registry_initialization() {
    let registry = PatchRegistry::new(Version::new(1, 0, 0), 0x1234);
    
    assert!(registry.active_patch().is_none());
    assert_eq!(registry.history().len(), 0);
}

#[test]
fn test_validator_with_compatible_versions() {
    let validator = Validator::new(Version::new(1, 0, 0), 0x1234);
    
    let _metadata = PatchMetadata::new(
        "test-patch".to_string(),
        Version::new(1, 0, 0),
        Version::new(1, 0, 0),
        0x1234,
    );
    
    // Note: This would require a mock library for full validation
    // For now, we test the validator creation (which should not panic)
    let _with_config = validator.with_config(ValidationConfig::strict());
}

#[test]
fn test_version_compatibility() {
    let v1_0_0 = Version::new(1, 0, 0);
    let v1_1_0 = Version::new(1, 1, 0);
    let v1_2_3 = Version::new(1, 2, 3);
    let v2_0_0 = Version::new(2, 0, 0);
    
    // Same major version should be compatible
    assert!(v1_0_0.is_compatible(&v1_1_0));
    assert!(v1_0_0.is_compatible(&v1_2_3));
    assert!(v1_1_0.is_compatible(&v1_2_3));
    
    // Different major version should not be compatible
    assert!(!v1_0_0.is_compatible(&v2_0_0));
    assert!(!v1_1_0.is_compatible(&v2_0_0));
}

#[test]
fn test_validation_config() {
    let strict = ValidationConfig::strict();
    assert!(strict.check_version);
    assert!(strict.check_layouts);
    assert!(strict.check_hash);
    assert!(strict.strict);
    
    let permissive = ValidationConfig::permissive();
    assert!(!permissive.check_version);
    assert!(!permissive.check_layouts);
    assert!(!permissive.check_hash);
    assert!(!permissive.strict);
}

#[test]
fn test_metadata_creation() {
    let metadata = PatchMetadata::new(
        "my-patch".to_string(),
        Version::new(2, 1, 0),
        Version::new(1, 0, 0),
        0xabcd,
    )
    .with_description("Test patch".to_string())
    .with_author("Test Author".to_string());
    
    assert_eq!(metadata.name, "my-patch");
    assert_eq!(metadata.version, Version::new(2, 1, 0));
    assert_eq!(metadata.interface_version, Version::new(1, 0, 0));
    assert_eq!(metadata.type_hash, 0xabcd);
    assert_eq!(metadata.description, Some("Test patch".to_string()));
    assert_eq!(metadata.author, Some("Test Author".to_string()));
}