A very simple and easy-to-use JSON generation tool that supports customizable formats and can be extended with custom Placeholders.
``` rust use mockjson::mock; use serdejson::json;
let val = mock(&json!({ "code":0, "msg":"just text", "data":[{ "id":"@Id|10", "title": "@Title", "datetime":"@DateTime", "author":{ "name":"@Name", "id":"@Guid", "email":"@Email", "id_number":"@IdNumber", "ip":"@Ip", "phones":["@Phone", 1, 3], "blog":"@Url", "avatar":"@Image|80X80|f7f7f7|fff" } }, 5, 20] })); ```
The above code will return a serde_json::Value, and after calling val.to_string(), its content will be as follows:
json
{
"code": 0,
"msg": "just text",
"data": [
{
"author": {
"avatar": "https://dummyimage.com/80X80/f7f7f7/fff",
"blog": "https://fvopl.ktuh.int/dcvr",
"email": "vpar@hslsl.org",
"id": "ceE68058-5EaB-4bc2-cCc8-F4a2Dff1Fe6A",
"id_number": "646734191701136174",
"ip": "132.86.194.66",
"name": "Patricia Garcia",
"phones": [
"13318945147",
"14923999763"
]
},
"datetime": "1960-02-12 03:49:48",
"id": "3217A3bAAa",
"title": "bymebox wpvvpv udp pcb lky onigkew sywtnhq"
},
...
]
}
To generate a list of data, you can use the format [json, min, max], which generates a number of data greater than min and less than max.
rust
let val = mock(&json!([{"user_name": "@Name", "email": "@Email", "age":"@Number|18~100"}, 2, 5]));
then calling val.to_string(), its content will be:
json
[
{
"age": 43,
"email": "dbjfm@drgmz.com",
"user_name":"Laura White"
},
{
"age": 35,
"email": "fbac@yefq.edu",
"user_name":"Frank Hernandez"
},
{
"age": 31,
"email": "kkhbo@vbqv.cn",
"user_name":"Jose Wilson"
}
]
The principle is to replace the placeholders with the corresponding content. Each placeholder starts with @, followed by a placeholder name, and optional parameters separated by |. For example, @Id will generate a string of length 12 containing [a-zA-Z0-9]. If you want to generate an id of length 5, just use @Id|5.
The return value of each placeholder is serde_json::Value.
The default placeholders provided are as follows:
Randomly generates a string in the format of xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx, without any parameters.
rust
mock(&json!("@Guid")); // String("753c33fE-fFdB-12aF-bC44-A9DD2D7E10aA")
Randomly generates a string of length 12 containing [a-zA-Z0-9]. If you want to generate an id of a custom length, use @Id|5 as an example.
```rust // Default length: 12 mock($json!("@Id")); // String("YNyxSBVzgpQd")
// Custom length mock(&json!("@Id|5")); // String("vygCt") ```
Randomly generates a Chinese ID number, no accept params.
rust
mock(&json!("@IdNumber")); // String("665471198804049116")
Randomly generates a Chinese phone number, no accept params.
rust
mock(&json!("@Phone")); // String("13983370699")
mock(&json!("@Phone|86")); // String("+86 13545607699")
Randomly generates a boolean value, no accept params.
rust
mock(&json!("@Bool")); // Bool(true)
Randomly generates an English name. It can accept parameters. If you want to generate a Chinese name, you can pass the parameter cn.
```rust mock(&json!("@Name")); // String("Donald Davis")
// Generate a Chinese name mock(&jsonQ("@Name|cn")); // String("蔡茗泽") ```
Randomly generates a first name. It can accept parameters. If you want to generate a Chinese first name, you can pass the parameter cn.
```rust mock(&json!("@FirstName")); // String("Mark")
// Generate a Chinese surname mock(&json!("@FirstName|cn")); // String("张") ```
Randomly generates a last name. It can accept parameters. If you want to generate a Chinese last name, you can pass the parameter cn.
```rust mock(&json!("@LastName")); // String("Martin")
// Generate a Chinese last name mock(&json!("@LastName|cn")); // String("沐宸") ```
Randomly generates a URL. The protocol of the URL can be customized.
```rust mock(&json!("@Url")); // String("https://mqezx.rpmy.int/gevc")
// Customize the URL protocol mock(&json!("@Url|ftp")); // String("ftp://qjwb.wpukq.gov/tmkwq") ```
Randomly generates an email address, no accept params.
rust
mock(&json!("@Email")); // String("hhci@engu.cn")
Randomly generates an IP address. By default, the IP format is IPv4, but it also supports generating IPv6 addresses by passing in ipV6.
```rust // ipv4 mock(&json!("@Ip")); // String("161.26.255.122")
// ipv6 mock(&json!("@Ip|ipV6")); // String("D991:53F9:2131:D6CA:86DA:56C4:156D:91B0") ```
Randomly generates a domain name, no accept params.
rust
mock(&json!("@Domain")); // String("hxca.gov")
Generates a URL for an image provided by https://dummyimage.com. The size, background color, and foreground color can be specified, but it is not possible to define only the background or foreground color.
```rust // Default image size is 320X240, with black background and white foreground mock(&json!("@Image")); // String("https://dummyimage.com/320X240/000/fff")
// Custom image size mock(&json!("@Image|40X40")); // String("https://dummyimage.com/40X40/000/fff")
// Custom size and background color mock(&json!("@Image|40X40|f00")); // String("https://dummyimage.com/40X40/f00/fff")
// Custom size, background color, and foreground color mock(&json!("@Image|40X40|f00|fea")); // String("https://dummyimage.com/40X40/f00/fea") ```
Randomly generates a natural number between 0 and 1000 by default. Accepts parameters to specify a range using @Number|min~max.
```rust mock(&json!("@Number")); // Number(326)
mock(&json!("@Number|100~999")); //Number(437)
mock(&json!("@Number|-200~-100")); // Number(-147) ```
Generates a floating-point number with a default precision of 2. Accepts parameters to specify precision and value range. The maximum precision is 5, and it is not possible to define only the value range.
```rust mock(&json!("@Float")); // Number(0.13)
// Specify precision mock(&json!("@Float|3")); // Number(0.628)
// Specify precision and value range, it is not possible to define only the value range. mock(&json!("@Float|2|100~999")); // Number(131.99) ```
Randomly generates a postal code.
rust
mock(&json!("@Zip")); // String("859615")
Randomly generates an address. Pass in cn to generate a Chinese address.
```rust mock(&json!("@Address")); //String("2454 Kidd Avenue Anchorage Alaska")
// Generate a Chinese address mock(&json!("@Address|cn")); //String("湖北省武汉市汉阳区仙山社区") ```
Randomly generates a date. The format can be customized.
```rust mock(&json!("@Date")); //String("1984-09-28")
// Custom date format mock(&json!("@Date|YYYY/MM/DD")); //String("1918/01/13")
mock(&json!("@Date|YY/M/D")); //String("36/2/1") ```
Randomly generates a time.
rust
mock(&json!("@Time")); //String("09:58:54")
Randomly generates a date and time. The format can be customized.
```rust mock(&json!("@DateTime")); //String("1937-06-24 10:47:53")
// Custom format mock(&json!("@DateTime|YYYY/MM/DD hh:mm:ss")); //String("2007/01/23 16:52:03") ```
Randomly generates a timestamp.
rust
mock(&json!("@Timestamp")); //Number(1812982294012)
Randomly generates a color in hex format.
rust
mock(&json!("@Color")); //String("#F4F54B")
Randomly generates a color in RGB format.
rust
mock(&json!("@RGB")); //String("rgb(79,134,9)")
Randomly generates a color in RGBA format.
rust
mock(&json!("@RGBA")); //String("rgba(240,131,198,0.65)")
Randomly generates a color in HSL format.
rust
mock(&json!("@HSL")); //String("hsl(343,50,32)")
placeholdersThe above are all the placeholders currently available. You can also register your own placeholders through the registry function, it must implements the MockFn trait. However, you cannot register placeholders that already exist. Although there is no strict naming convention for placeholders, it is still recommended to use camel case. Except for abbreviations like RGB.
For example: Now I want to register a placeholder called @CMYK, which is used to generate color in cmyk format.
```rust
pub struct MockCMYKFn;
impl MockFn for MockCMYKFn {
// Ignore the parameter since it is not used here.
fn mock(&self, :Option
// Register registry("@CMYK", MockCMYKFn);
// Usage mock(&json!("@CMYK")); // String("cmyk(99,20,87,54))) ```