messagepack-cli 0.1.0

CLI tool to convert MessagePack data to JSON and vice versa.
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 std::f64::consts::PI;

use error_stack::{Report, ResultExt};
use messagepack_cli::{ConversionDirection, Converter};
use serde::{Deserialize, Serialize};
use thiserror::Error;

#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct Root {
	a: Vec<SubPath>,
	b: Option<f32>,
	c: Option<bool>,
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct SubPath {
	b: bool,
	floats: Vec<f64>,
	string: String,
	ints: Vec<i64>, // i128 is not supported :/
}

impl Root {
	fn test() -> Self {
		Self {
			a: vec![
				SubPath {
					b: true,
					floats: vec![1.0, PI, 3.57, 0.0],
					string: "\"\"™".to_owned(),
					ints: vec![0, 12, 99_999_999_999_999_999],
				},
				SubPath { b: false, floats: vec![], string: "".to_owned(), ints: vec![] },
			],
			b: Some(1.2345),
			c: None,
		}
	}
}

#[derive(Debug, Error)]
#[error("Test failed")]
struct Error;

#[test]
fn automatic() -> Result<(), Report<Error>> {
	let data = Root::test();

	let json = serde_json::to_vec(&data).change_context(Error)?;
	let msgpack = rmp_serde::to_vec_named(&data).change_context(Error)?;

	let mut output_msgpack = Vec::new();
	Converter::new(json.as_slice(), &mut output_msgpack, ConversionDirection::Auto)
		.execute()
		.change_context(Error)?;
	let mut output_json = Vec::new();
	Converter::new(msgpack.as_slice(), &mut output_json, ConversionDirection::Auto)
		.execute()
		.change_context(Error)?;

	let data_json2msgpack: Root = rmp_serde::from_slice(&output_msgpack).change_context(Error)?;
	let data_msgpack2json: Root = serde_json::from_slice(&output_json).change_context(Error)?;
	assert_eq!(data_json2msgpack, data);
	assert_eq!(data_msgpack2json, data);

	Ok(())
}

#[test]
fn json() -> Result<(), Report<Error>> {
	let data = Root::test();
	let json = serde_json::to_vec(&data).change_context(Error)?;

	let mut output_msgpack = Vec::new();
	Converter::new(json.as_slice(), &mut output_msgpack, ConversionDirection::Json2MsgPack)
		.execute()
		.change_context(Error)?;
	let output_data: Root = rmp_serde::from_slice(&output_msgpack).change_context(Error)?;
	assert_eq!(output_data, data);

	let mut output_json = Vec::new();
	Converter::new(output_msgpack.as_slice(), &mut output_json, ConversionDirection::MsgPack2Json)
		.execute()
		.change_context(Error)?;
	let output_data: Root = serde_json::from_slice(&output_json).change_context(Error)?;
	assert_eq!(output_data, data);

	Ok(())
}

#[test]
fn msgpack() -> Result<(), Report<Error>> {
	let data = Root::test();
	let msgpack = rmp_serde::to_vec_named(&data).change_context(Error)?;

	let mut output_json = Vec::new();
	Converter::new(msgpack.as_slice(), &mut output_json, ConversionDirection::MsgPack2Json)
		.execute()
		.change_context(Error)?;
	let output_data: Root = serde_json::from_slice(&output_json).change_context(Error)?;
	assert_eq!(output_data, data);

	let mut output_msgpack = Vec::new();
	Converter::new(output_json.as_slice(), &mut output_msgpack, ConversionDirection::Json2MsgPack)
		.execute()
		.change_context(Error)?;
	let output_data: Root = rmp_serde::from_slice(&output_msgpack).change_context(Error)?;
	assert_eq!(output_data, data);

	Ok(())
}