data_generator 0.1.119

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

use data_generator::config::GeneratorConfig;
use data_generator::{DataGenerator, Result};
use std::path::PathBuf;
use tempfile::TempDir;

/// Helper function to create a temporary directory for test outputs
fn create_test_dir() -> TempDir {
    tempfile::tempdir().expect("Failed to create temp directory")
}

/// Helper function to create a simple SHACL schema file
fn create_simple_shacl_schema(temp_dir: &TempDir) -> PathBuf {
    let schema_path = temp_dir.path().join("test_shacl.ttl");
    std::fs::write(
        &schema_path,
        r#"
@prefix :       <http://example.org/> .
@prefix sh:     <http://www.w3.org/ns/shacl#> .
@prefix xsd:    <http://www.w3.org/2001/XMLSchema#> .
        
:Person a sh:NodeShape ;
   sh:closed true ;
   sh:property [                  
    sh:path     :name ; 
    sh:minCount 1; 
    sh:maxCount 1;
    sh:datatype xsd:string ;
  ] ;
  sh:property [                   
   sh:path     :age ; 
   sh:maxCount 1; 
   sh:datatype xsd:integer ;
  ] .
    "#,
    )
    .expect("Failed to write test SHACL schema");
    schema_path
}

#[tokio::test]
async fn test_shacl_schema_loading() -> Result<()> {
    let temp_dir = create_test_dir();
    let schema_path = create_simple_shacl_schema(&temp_dir);
    let output_path = temp_dir.path().join("output.ttl");

    let mut config = GeneratorConfig::default();
    config.output.path = output_path.clone();
    config.generation.entity_count = 5; // Small number for testing

    let mut generator = DataGenerator::new(config)?;

    // Test SHACL schema loading
    generator.load_shacl_schema(&schema_path).await?;

    println!("SHACL schema loaded successfully");
    Ok(())
}

#[tokio::test]
async fn test_shacl_data_generation() -> Result<()> {
    let temp_dir = create_test_dir();
    let schema_path = create_simple_shacl_schema(&temp_dir);
    let output_path = temp_dir.path().join("output.ttl");

    let mut config = GeneratorConfig::default();
    config.output.path = output_path.clone();
    config.generation.entity_count = 3; // Small number for testing

    let mut generator = DataGenerator::new(config)?;

    // Test complete SHACL pipeline: load schema and generate data
    generator.load_shacl_schema(&schema_path).await?;
    generator.generate().await?;

    // Verify output file exists and has content
    assert!(output_path.exists(), "Output file should exist");
    let content = std::fs::read_to_string(&output_path)?;
    assert!(!content.is_empty(), "Output file should not be empty");

    println!("Generated SHACL-based data:");
    println!("{content}");

    Ok(())
}

#[tokio::test]
async fn test_shacl_auto_detection() -> Result<()> {
    let temp_dir = create_test_dir();
    let schema_path = create_simple_shacl_schema(&temp_dir);
    let output_path = temp_dir.path().join("output.ttl");

    let mut config = GeneratorConfig::default();
    config.output.path = output_path.clone();
    config.generation.entity_count = 2;

    let mut generator = DataGenerator::new(config)?;

    // Test auto-detection of SHACL format based on .ttl extension
    generator.load_schema_auto(&schema_path).await?;
    generator.generate().await?;

    // Verify output file exists and has content
    assert!(output_path.exists(), "Output file should exist");
    let content = std::fs::read_to_string(&output_path)?;
    assert!(!content.is_empty(), "Output file should not be empty");

    println!("Generated data using auto-detection:");
    println!("{content}");

    Ok(())
}