noyalib 0.0.1

A pure Rust YAML library with zero unsafe code and full serde integration
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

// SPDX-License-Identifier: MIT OR Apache-2.0
// Copyright (c) 2026 Noyalib. All rights reserved.

//! Streaming `!!binary` support.
//!
//! Verifies that [`StreamingDeserializer`] honours `!!binary` tags
//! directly — decoding RFC 4648 base64 on demand without falling
//! back to the AST path. Drives the deserializer with the public
//! constructors so the tests exercise the same code that downstream
//! users hit.

#![allow(missing_docs)]

use noyalib::StreamingDeserializer;
use serde::{Deserialize, Serialize};
use serde_bytes::ByteBuf;

#[derive(Debug, Deserialize, PartialEq)]
struct Payload {
    name: String,
    #[serde(with = "serde_bytes")]
    body: Vec<u8>,
}

#[test]
fn streaming_decodes_inline_binary() {
    let yaml = "name: snapshot\nbody: !!binary SGVsbG8sIFdvcmxkIQ==\n";
    let mut de = StreamingDeserializer::new(yaml);
    let p = Payload::deserialize(&mut de).unwrap();
    assert_eq!(p.name, "snapshot");
    assert_eq!(p.body, b"Hello, World!");
}

#[test]
fn streaming_decodes_block_scalar_binary() {
    // Multi-line block-scalar — the typical layout for real-world
    // `!!binary` payloads. Newlines/indents inside the scalar must
    // be stripped before base64-decoding.
    let yaml = "\
name: snapshot
body: !!binary |
  SGVsbG8s
  IFdvcmxk
  IQ==
";
    let mut de = StreamingDeserializer::new(yaml);
    let p = Payload::deserialize(&mut de).unwrap();
    assert_eq!(p.body, b"Hello, World!");
}

#[test]
fn streaming_byte_buf_roundtrip() {
    #[derive(Debug, Deserialize, PartialEq)]
    struct Wrapper {
        data: ByteBuf,
    }
    let yaml = "data: !!binary SGVsbG8sIFdvcmxkIQ==\n";
    let mut de = StreamingDeserializer::new(yaml);
    let w = Wrapper::deserialize(&mut de).unwrap();
    assert_eq!(w.data.as_ref(), b"Hello, World!");
}

#[test]
fn streaming_full_byte_range() {
    #[derive(Debug, Serialize, Deserialize, PartialEq)]
    struct Wrapper {
        data: ByteBuf,
    }
    let original: Vec<u8> = (0u8..=255).collect();
    // Round-trip via the canonical encoder, then drive deserialise
    // via the streaming path.
    let yaml = noyalib::to_string(&Wrapper {
        data: ByteBuf::from(original.clone()),
    })
    .unwrap();
    let mut de = StreamingDeserializer::new(&yaml);
    let round = Wrapper::deserialize(&mut de).unwrap();
    assert_eq!(round.data.as_ref(), original.as_slice());
}

#[test]
fn streaming_rejects_invalid_base64() {
    let yaml = "name: x\nbody: !!binary \"not valid base64!\"\n";
    let mut de = StreamingDeserializer::new(yaml);
    let res: Result<Payload, _> = Payload::deserialize(&mut de);
    assert!(res.is_err(), "non-base64 !!binary content must error");
}

#[test]
fn streaming_untagged_string_visits_raw_bytes() {
    // Without a `!!binary` tag, deserialising into a byte target
    // surfaces the underlying scalar bytes verbatim — base64-decoding
    // is opt-in via the tag.
    #[derive(Debug, Deserialize)]
    struct Wrapper {
        data: ByteBuf,
    }
    let yaml = "data: hello\n";
    let mut de = StreamingDeserializer::new(yaml);
    let w = Wrapper::deserialize(&mut de).unwrap();
    assert_eq!(w.data.as_ref(), b"hello");
}