mruby-serde-json 0.1.0

extern crate mruby_serde_json;
extern crate mrubyedge;

mod helpers;
use helpers::*;

#[test]
fn test_json_load_integer() {
    let code = r#"
    JSON.load("42")
    "#;
    let binary = mrbc_compile("json_load_integer", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    mruby_serde_json::init_json(&mut vm);

    let result = vm.run().unwrap();
    let value: i64 = result.as_ref().try_into().unwrap();
    assert_eq!(value, 42);
}

#[test]
fn test_json_load_string() {
    let code = r#"
    JSON.load('"hello"')
    "#;
    let binary = mrbc_compile("json_load_string", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    mruby_serde_json::init_json(&mut vm);

    let result = vm.run().unwrap();
    let value: String = result.as_ref().try_into().unwrap();
    assert_eq!(value, "hello");
}

#[test]
fn test_json_load_array() {
    let code = r#"
    result = JSON.load('[
      1,
      2,
      3
    ]')
    result
    "#;
    let binary = mrbc_compile("json_load_array", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    mruby_serde_json::init_json(&mut vm);

    let result = vm.run().unwrap();
    if let mrubyedge::yamrb::value::RValue::Array(arr) = &result.value {
        assert_eq!(arr.borrow().len(), 3);
        let v0: i64 = arr.borrow()[0].as_ref().try_into().unwrap();
        let v1: i64 = arr.borrow()[1].as_ref().try_into().unwrap();
        let v2: i64 = arr.borrow()[2].as_ref().try_into().unwrap();
        assert_eq!(v0, 1);
        assert_eq!(v1, 2);
        assert_eq!(v2, 3);
    } else {
        panic!("Expected array result");
    }
}

#[test]
fn test_json_load_hash() {
    let code = r#"
    result = JSON.load('{
      "name": "Alice",
      "age": 30
    }')
    result["name"]
    "#;
    let binary = mrbc_compile("json_load_hash_name", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    mruby_serde_json::init_json(&mut vm);
    let result = vm.run().unwrap();
    let name: String = result.as_ref().try_into().unwrap();
    assert_eq!(name, "Alice");

    let code2 = r#"
    result = JSON.load('{
      "name": "Alice",
      "age": 30
    }')
    result["age"]
    "#;
    let binary2 = mrbc_compile("json_load_hash_age", code2);
    let mut rite2 = mrubyedge::rite::load(&binary2).unwrap();
    let mut vm2 = mrubyedge::yamrb::vm::VM::open(&mut rite2);
    mruby_serde_json::init_json(&mut vm2);
    let result2 = vm2.run().unwrap();
    let age: i64 = result2.as_ref().try_into().unwrap();
    assert_eq!(age, 30);
}

#[test]
fn test_json_load_nested_structure() {
    let code = r#"
    result = JSON.load('{
      "users": [
        {
          "name": "Bob",
          "age": 25
        },
        {
          "name": "Carol",
          "age": 28
        }
      ]
    }')
    result["users"][0]["name"]
    "#;
    let binary = mrbc_compile("json_load_nested", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    mruby_serde_json::init_json(&mut vm);

    let result = vm.run().unwrap();
    let name: String = result.as_ref().try_into().unwrap();
    assert_eq!(name, "Bob");

    let code2 = r#"
    result = JSON.load('{
      "users": [
        {
          "name": "Bob",
          "age": 25
        },
        {
          "name": "Carol",
          "age": 28
        }
      ]
    }')
    result["users"][1]["name"]
    "#;
    let binary2 = mrbc_compile("json_load_nested2", code2);
    let mut rite2 = mrubyedge::rite::load(&binary2).unwrap();
    let mut vm2 = mrubyedge::yamrb::vm::VM::open(&mut rite2);
    mruby_serde_json::init_json(&mut vm2);
    let result2 = vm2.run().unwrap();
    let name2: String = result2.as_ref().try_into().unwrap();
    assert_eq!(name2, "Carol");
}

#[test]
fn test_json_load_boolean() {
    let code = r#"
    JSON.load("true")
    "#;
    let binary = mrbc_compile("json_load_bool", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    mruby_serde_json::init_json(&mut vm);

    let result = vm.run().unwrap();
    let value: bool = result.as_ref().try_into().unwrap();
    assert_eq!(value, true);
}

#[test]
fn test_json_load_boolean_2() {
    let code = r#"
    JSON.load("false")
    "#;
    let binary = mrbc_compile("json_load_bool_2", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    mruby_serde_json::init_json(&mut vm);

    let result = vm.run().unwrap();
    let value: bool = result.as_ref().try_into().unwrap();
    assert_eq!(value, false);
}

#[test]
fn test_json_load_nil() {
    let code = r#"
    JSON.load("null")
    "#;
    let binary = mrbc_compile("json_load_nil", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    mruby_serde_json::init_json(&mut vm);

    let result = vm.run().unwrap();
    assert!(result.is_nil());
}

#[test]
fn test_json_load_float() {
    let code = r#"
    JSON.load("3.1415")
    "#;
    let binary = mrbc_compile("json_load_float", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    mruby_serde_json::init_json(&mut vm);

    let result = vm.run().unwrap();
    let value: f64 = result.as_ref().try_into().unwrap();
    assert_eq!(value, 3.1415);
}

#[test]
fn test_json_load_key() {
    let code = r#"
    result = JSON.load('{
      "status": "ok"
    }')
    result["status"]
    "#;
    let binary = mrbc_compile("json_load_key", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    mruby_serde_json::init_json(&mut vm);

    let result = vm.run().unwrap();
    let value: String = result.as_ref().try_into().unwrap();
    assert_eq!(value, "ok");
}