mockery 0.2.1

Generate mock data based on a specification file for a variety of purposes
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

use crate::datatypes::RandomData;

use serde_derive::{Deserialize, Serialize};
use std::collections::HashMap;
use std::string::ToString;

type Map<T> = HashMap<String, T>;
type GeneratedProperties = Map<String>;
type GeneratedModels = Map<GeneratedProperties>;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Model(pub HashMap<String, RandomData>);

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelMap {
	serialize: HashMap<String, Vec<String>>,
	models: HashMap<String, Model>,
}

impl Model {
	pub fn new() -> Self {
		Model(HashMap::new())
	}

	pub fn add_property<TS>(&mut self, name: TS, definition: RandomData) -> &mut Self
	where
		TS: ToString,
	{
		self.0.insert(name.to_string(), definition);
		self
	}
	pub fn get_property(&self, name: String) -> Option<&RandomData> {
		self.0.get(&name)
	}
	pub fn generate_data(&self) -> GeneratedProperties {
		let mut generated = HashMap::with_capacity(self.0.len());
		for (name, generator) in &self.0 {
			generated.insert(name.clone(), generator.to_string());
		}

		generated
	}
	/// Returns a list of types in this model that reference other models. The [RandomData] in the tuple will always
	/// be a [RandomData::Reference] type
	pub fn get_reference_types(&self) -> Vec<(String, RandomData)> {
		self.0
			.iter()
			.filter_map(|(key, value)| match value {
				RandomData::Reference { .. } => Some((key.to_string(), value.clone())),
				_ => None,
			})
			.collect()
	}
}

pub mod io {
	use crate::model::ModelMap;

	use serde_json::from_str;
	use std::fs::read_to_string;
	use std::io::{Error, Result};
	use std::path::Path;

	pub fn read_from_spec<P>(path: P) -> Result<ModelMap>
	where
		P: AsRef<Path>,
	{
		let file = read_to_string(path.as_ref())?;
		from_str(&file).map_err(|e| Error::from(e))
	}
	//    pub fn _write_to_spec<P>(model: ModelMap, path: P) -> Result<()> where P: AsRef<Path> {
	//        let output = to_string(&model);
	//        println!("{:?}", output);
	//        Ok(())
	//    }
}

impl ModelMap {
	pub fn new() -> Self {
		ModelMap {
			serialize: HashMap::new(),
			models: HashMap::new(),
		}
	}

	pub fn add_model<TS>(&mut self, name: TS, model: Model) -> &mut Self
	where
		TS: ToString,
	{
		self.models.insert(name.to_string(), model);
		self
	}
	pub fn get_model(&self, name: String) -> Option<&Model> {
		self.models.get(&name)
	}
	pub fn generate_data(&self) -> GeneratedModels {
		let mut generated = HashMap::with_capacity(self.models.len());
		for (name, model) in &self.models {
			generated.insert(name.clone(), model.generate_data());
		}

		generated
	}
	pub fn get_models_ref(&self) -> &HashMap<String, Model> {
		&self.models
	}
	pub fn get_serialize_ref(&self) -> &HashMap<String, Vec<String>> {
		&self.serialize
	}
}

#[test]
fn generate_random_data() {
	use crate::datatypes::RandomData;
	use crate::model::Model;

	let mut model = Model::new();

	model
		.add_property("name".to_owned(), RandomData::FullName)
		.add_property("email".to_owned(), RandomData::Email);

	println!("Random user: {:?}", model.generate_data());
}