config-disassembler 0.1.0

//! End-to-end round-trip tests for the JSON/JSON5/YAML disassembler.

use std::fs;
use std::path::PathBuf;

use config_disassembler::disassemble::{self, DisassembleOptions};
use config_disassembler::format::Format;
use config_disassembler::reassemble::{self, ReassembleOptions};
use serde_json::{json, Value};

fn write_input(dir: &std::path::Path, name: &str, contents: &str) -> PathBuf {
    let path = dir.join(name);
    fs::write(&path, contents).unwrap();
    path
}

fn parse_value(format: Format, path: &std::path::Path) -> Value {
    format.load(path).unwrap()
}

#[test]
fn json_object_roundtrip_through_yaml_files() {
    let tmp = tempfile::tempdir().unwrap();
    let original = json!({
        "name": "demo",
        "version": 3,
        "enabled": true,
        "settings": {
            "retries": 5,
            "endpoints": ["a", "b", "c"]
        },
        "tags": ["alpha", "beta"]
    });
    let input = write_input(
        tmp.path(),
        "config.json",
        &serde_json::to_string_pretty(&original).unwrap(),
    );

    let disassembled = disassemble::disassemble(DisassembleOptions {
        input: input.clone(),
        input_format: Some(Format::Json),
        output_dir: Some(tmp.path().join("split")),
        output_format: Some(Format::Yaml),
        unique_id: None,
        pre_purge: false,
        post_purge: false,
    })
    .unwrap();

    assert!(disassembled.join("settings.yaml").exists());
    assert!(disassembled.join("tags.yaml").exists());
    assert!(disassembled.join("_main.yaml").exists());
    assert!(disassembled
        .join(config_disassembler::meta::META_FILENAME)
        .exists());

    let output = reassemble::reassemble(ReassembleOptions {
        input_dir: disassembled,
        output: Some(tmp.path().join("rebuilt.json")),
        output_format: Some(Format::Json),
        post_purge: false,
    })
    .unwrap();

    let rebuilt = parse_value(Format::Json, &output);
    assert_eq!(rebuilt, original);
}

#[test]
fn yaml_array_roundtrip_with_unique_id() {
    let tmp = tempfile::tempdir().unwrap();
    let yaml = r#"
- name: alpha
  weight: 1
- name: beta
  weight: 2
- name: gamma
  weight: 3
"#;
    let input = write_input(tmp.path(), "items.yaml", yaml);

    let disassembled = disassemble::disassemble(DisassembleOptions {
        input: input.clone(),
        input_format: Some(Format::Yaml),
        output_dir: Some(tmp.path().join("items")),
        output_format: Some(Format::Json),
        unique_id: Some("name".into()),
        pre_purge: false,
        post_purge: false,
    })
    .unwrap();

    assert!(disassembled.join("alpha.json").exists());
    assert!(disassembled.join("beta.json").exists());
    assert!(disassembled.join("gamma.json").exists());

    let output = reassemble::reassemble(ReassembleOptions {
        input_dir: disassembled,
        output: Some(tmp.path().join("rebuilt.yaml")),
        output_format: Some(Format::Yaml),
        post_purge: false,
    })
    .unwrap();

    let rebuilt = parse_value(Format::Yaml, &output);
    let original = parse_value(Format::Yaml, &input);
    assert_eq!(rebuilt, original);
}

#[test]
fn json5_roundtrip_preserves_structure() {
    let tmp = tempfile::tempdir().unwrap();
    let json5_text = r#"{
  // A small json5 sample
  name: 'sample',
  enabled: true,
  count: 42,
  servers: [
    { host: 'a.example.com', port: 8080 },
    { host: 'b.example.com', port: 8081 },
  ],
  meta: {
    region: 'us-east-1',
    flags: ['x', 'y'],
  },
}
"#;
    let input = write_input(tmp.path(), "config.json5", json5_text);

    let disassembled = disassemble::disassemble(DisassembleOptions {
        input: input.clone(),
        input_format: Some(Format::Json5),
        output_dir: Some(tmp.path().join("split")),
        output_format: Some(Format::Json5),
        unique_id: None,
        pre_purge: false,
        post_purge: false,
    })
    .unwrap();

    let output = reassemble::reassemble(ReassembleOptions {
        input_dir: disassembled,
        output: Some(tmp.path().join("rebuilt.json5")),
        output_format: Some(Format::Json5),
        post_purge: false,
    })
    .unwrap();

    let rebuilt = parse_value(Format::Json5, &output);
    let original = parse_value(Format::Json5, &input);
    assert_eq!(rebuilt, original);
}

#[test]
fn pre_purge_clears_output_dir() {
    let tmp = tempfile::tempdir().unwrap();
    let input = write_input(tmp.path(), "c.json", r#"{"a": {"b": 1}}"#);
    let out = tmp.path().join("split");
    fs::create_dir_all(&out).unwrap();
    fs::write(out.join("stale.txt"), "old data").unwrap();

    disassemble::disassemble(DisassembleOptions {
        input,
        input_format: Some(Format::Json),
        output_dir: Some(out.clone()),
        output_format: Some(Format::Json),
        unique_id: None,
        pre_purge: true,
        post_purge: false,
    })
    .unwrap();

    assert!(!out.join("stale.txt").exists());
    assert!(out.join("a.json").exists());
}

#[test]
fn post_purge_removes_input_file() {
    let tmp = tempfile::tempdir().unwrap();
    let input = write_input(tmp.path(), "c.json", r#"{"a": {"b": 1}}"#);

    disassemble::disassemble(DisassembleOptions {
        input: input.clone(),
        input_format: Some(Format::Json),
        output_dir: Some(tmp.path().join("split")),
        output_format: Some(Format::Json),
        unique_id: None,
        pre_purge: false,
        post_purge: true,
    })
    .unwrap();

    assert!(!input.exists());
}