rig-core 0.47.0

An opinionated library for building LLM powered applications.
Documentation
use serde::Deserialize;
use serde_json::json;

use super::*;

#[derive(Debug, Deserialize, PartialEq)]
#[serde(deny_unknown_fields)]
struct Args {
    offset: Option<usize>,
    timeout_secs: Option<u64>,
    #[serde(default)]
    delta: i32,
    #[serde(default)]
    scale: f64,
    #[serde(default)]
    raw: Value,
    #[serde(default)]
    edits: Vec<Edit>,
    mode: Option<Mode>,
}

#[derive(Debug, Deserialize, PartialEq)]
struct Edit {
    line: u32,
}

#[derive(Debug, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
enum Mode {
    Fast,
    Lines(u16),
    Window { first: u8 },
}

fn decoded(args: Value) -> Option<Args> {
    decode_args(&args).ok()
}

#[test]
fn an_integral_float_is_the_integer_its_field_asks_for() {
    let args = decoded(json!({
        "offset": 1.0,
        "timeout_secs": 30.0,
        "delta": -2.0,
        "edits": [{"line": 7.0}],
        "mode": {"window": {"first": 3.0}},
    }));
    let edits = vec![Edit { line: 7 }];
    let mode = Some(Mode::Window { first: 3 });
    assert_eq!(args.as_ref().map(|args| args.offset), Some(Some(1)));
    assert_eq!(args.as_ref().map(|args| args.timeout_secs), Some(Some(30)));
    assert_eq!(args.as_ref().map(|args| args.delta), Some(-2));
    assert_eq!(args.as_ref().map(|args| &args.edits), Some(&edits));
    assert_eq!(args.as_ref().map(|args| &args.mode), Some(&mode));
    let lines = decoded(json!({"mode": {"lines": 4.0}})).and_then(|args| args.mode);
    assert_eq!(lines, Some(Mode::Lines(4)));
    let fast = decoded(json!({"mode": "fast"})).and_then(|args| args.mode);
    assert_eq!(fast, Some(Mode::Fast));
    let text = decode_text::<Args>(r#"{"offset": 1.0, "timeout_secs": 30.0}"#).ok();
    let read = text.map(|args| (args.offset, args.timeout_secs));
    assert_eq!(read, Some((Some(1), Some(30))));
}

#[test]
fn every_other_value_reaches_its_field_as_sent() {
    let args = decoded(json!({"scale": 2.0, "raw": {"at": 30.0, "n": 3}, "offset": 4}));
    assert_eq!(args.as_ref().map(|args| args.scale), Some(2.0));
    let raw = json!({"at": 30.0, "n": 3});
    assert_eq!(args.as_ref().map(|args| &args.raw), Some(&raw));
    assert!(raw.pointer("/at").is_some_and(Value::is_f64));
    assert_eq!(args.map(|args| args.offset), Some(Some(4)));
}

#[test]
fn a_fraction_a_negative_unsigned_and_an_overflow_are_refused_not_rounded() {
    for args in [
        json!({"offset": 1.5}),
        json!({"offset": -1.0}),
        json!({"offset": -1}),
        json!({"offset": 1e30}),
        json!({"delta": 3e9}),
        json!({"edits": [{"line": 0.5}]}),
        json!({"mode": {"window": {"first": 300.0}}}),
    ] {
        assert_eq!(decoded(args.clone()), None, "{args}");
    }
    assert!(decoded(json!({"unknown": 1})).is_none());
    // A refusal of text is worded as `serde_json` words it, with its place.
    let refused = decode_text::<Args>(r#"{"offset": 1.5}"#)
        .err()
        .map(|error| error.to_string());
    assert!(refused.is_some_and(|why| why.contains(" at line 1 column ")));
}

#[test]
fn a_whole_number_is_one_a_64_bit_integer_holds() {
    let number = |value: Value| value.as_number().and_then(whole);
    assert_eq!(number(json!(30.0)), Some(Whole::Unsigned(30)));
    assert_eq!(number(json!(-0.0)), Some(Whole::Unsigned(0)));
    assert_eq!(number(json!(-2.0)), Some(Whole::Signed(-2)));
    assert_eq!(number(json!(u64::MAX)), Some(Whole::Unsigned(u64::MAX)));
    assert_eq!(number(json!(i64::MIN)), Some(Whole::Signed(i64::MIN)));
    assert_eq!(number(json!(18_446_744_073_709_551_616.0)), None);
    assert_eq!(number(json!(-9_223_372_036_854_777_856.0)), None);
    assert_eq!(number(json!(1e30)), None);
    assert_eq!(number(json!(1.5)), None);
}