rudof_generate 0.3.4

RDF data shapes implementation in Rust
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

#[cfg(not(target_family = "wasm"))]
use rudof_generate::GeneratorConfig;
#[cfg(not(target_family = "wasm"))]
use std::io::Write;
#[cfg(not(target_family = "wasm"))]
use tempfile::NamedTempFile;

/// Test that the basic DataGenerator can be created and configured
#[cfg(not(target_family = "wasm"))]
#[tokio::test]
async fn test_basic_generator_creation() {
    // Test that we can create a config and generator
    let output_file = NamedTempFile::new().unwrap();

    let mut config = GeneratorConfig::default();
    config.generation.entity_count = 3;
    config.output.path = output_file.path().to_path_buf();

    let generator = rudof_generate::DataGenerator::new(config);
    assert!(generator.is_ok(), "Should be able to create a DataGenerator");
}

/// Test that ShEx schemas can be loaded
#[cfg(not(target_family = "wasm"))]
#[tokio::test]
async fn test_shex_schema_loading() {
    // Create a simple ShEx schema
    let shex_schema = r#"
PREFIX ex: <http://example.org/>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>

ex:PersonShape {
  ex:name xsd:string
}
"#;

    // Create temporary files
    let mut schema_file = NamedTempFile::new().unwrap();
    writeln!(schema_file, "{shex_schema}").unwrap();

    let output_file = NamedTempFile::new().unwrap();

    // Configure generator
    let mut config = GeneratorConfig::default();
    config.generation.entity_count = 2;
    config.output.path = output_file.path().to_path_buf();

    // Test schema loading
    let mut generator = rudof_generate::DataGenerator::new(config).unwrap();
    let result = generator.load_shex_schema(schema_file.path()).await;

    assert!(result.is_ok(), "Should be able to load ShEx schema");
}

/// Test that SHACL schemas can be loaded
#[cfg(not(target_family = "wasm"))]
#[tokio::test]
async fn test_shacl_schema_loading() {
    // Create a simple SHACL schema
    let shacl_schema = r#"
@prefix sh: <http://www.w3.org/ns/shacl#> .
@prefix ex: <http://example.org/> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

ex:PersonShape a sh:NodeShape ;
    sh:targetClass ex:Person ;
    sh:property [
        sh:path ex:name ;
        sh:datatype xsd:string ;
        sh:minCount 1 ;
        sh:maxCount 1 ;
    ] .
"#;

    // Create temporary files
    let mut schema_file = NamedTempFile::new().unwrap();
    writeln!(schema_file, "{shacl_schema}").unwrap();

    let output_file = NamedTempFile::new().unwrap();

    // Configure generator
    let mut config = GeneratorConfig::default();
    config.generation.entity_count = 2;
    config.output.path = output_file.path().to_path_buf();

    // Test schema loading
    let mut generator = rudof_generate::DataGenerator::new(config).unwrap();
    let result = generator.load_shacl_schema(schema_file.path()).await;

    assert!(result.is_ok(), "Should be able to load SHACL schema");
}

/// Test that data generation produces output files
#[cfg(not(target_family = "wasm"))]
#[tokio::test]
async fn test_data_generation_produces_output() {
    // Create a simple SHACL schema
    let shacl_schema = r#"
@prefix sh: <http://www.w3.org/ns/shacl#> .
@prefix ex: <http://example.org/> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

ex:PersonShape a sh:NodeShape ;
    sh:targetClass ex:Person ;
    sh:property [
        sh:path ex:name ;
        sh:datatype xsd:string ;
        sh:minCount 1 ;
        sh:maxCount 1 ;
    ] .
"#;

    // Create temporary files
    let mut schema_file = NamedTempFile::new().unwrap();
    writeln!(schema_file, "{shacl_schema}").unwrap();

    let output_file = NamedTempFile::new().unwrap();

    // Configure generator
    let mut config = GeneratorConfig::default();
    config.generation.entity_count = 2;
    config.output.path = output_file.path().to_path_buf();

    // Generate data
    let mut generator = rudof_generate::DataGenerator::new(config).unwrap();
    generator.load_shacl_schema(schema_file.path()).await.unwrap();
    generator.load_shacl_schema(schema_file.path()).await.unwrap();
    let result = generator.generate().await;

    assert!(result.is_ok(), "Should be able to generate data");

    // Verify output file exists and has content
    assert!(output_file.path().exists(), "Output file should exist");
    let content = std::fs::read_to_string(output_file.path()).unwrap();
    assert!(!content.is_empty(), "Output file should have content");
}