anycms-core 0.4.1

use anycms_core::{ApiResult, FieldError, ResponseData, ResultPagination};
use serde::Serialize;
use serde_json::json;

#[derive(Debug, Serialize, PartialEq)]
struct User {
    id: u32,
    name: String,
}

#[test]
fn test_single_value_serialization() {
    let user = User {
        id: 1,
        name: "Alice".to_string(),
    };

    let result: ApiResult<User> = ApiResult::value(user);

    let json = serde_json::to_value(&result).unwrap();
    let expected = json!({
        "success": true,
        "data": {
            "id": 1,
            "name": "Alice"
        }
    });

    assert_eq!(json, expected);
}

#[test]
fn test_list_serialization() {
    let users = vec![
        User {
            id: 1,
            name: "Alice".to_string(),
        },
        User {
            id: 2,
            name: "Bob".to_string(),
        },
    ];

    let pagination = ResultPagination::new(100, 1, 10);
    let result: ApiResult<User> = ApiResult::list(users).with_pagination(pagination);

    let json = serde_json::to_value(&result).unwrap();
    let expected = json!({
        "success": true,
        "data": [
            { "id": 1, "name": "Alice" },
            { "id": 2, "name": "Bob" }
        ],
        "pagination": {
            "total": 100,
            "page": 1,
            "pageSize": 10,
            "currentPage": 1
        }
    });

    assert_eq!(json, expected);
}

#[test]
fn test_pagination_helpers() {
    let p = ResultPagination::new(95, 3, 10);
    assert_eq!(p.total_pages(), 10);
    assert!(p.has_next());
    assert!(p.has_prev());

    let p_last = ResultPagination::new(95, 10, 10);
    assert!(!p_last.has_next());

    let p_first = ResultPagination::new(95, 1, 10);
    assert!(!p_first.has_prev());
}

#[test]
fn test_empty_success() {
    let result: ApiResult<()> = ApiResult::ok();

    let json = serde_json::to_value(&result).unwrap();
    let expected = json!({
        "success": true
    });

    assert_eq!(json, expected);
}

#[test]
fn test_error_response() {
    let result: ApiResult<User> = ApiResult::fail("User not found").with_code(404);

    let json = serde_json::to_value(&result).unwrap();
    let expected = json!({
        "success": false,
        "message": "User not found",
        "code": 404
    });

    assert_eq!(json, expected);
}

#[test]
fn test_response_data_single() {
    let user = User {
        id: 1,
        name: "Alice".to_string(),
    };

    let data = ResponseData::single(user);
    let json = serde_json::to_value(&data).unwrap();

    let expected = json!({
        "id": 1,
        "name": "Alice"
    });

    assert_eq!(json, expected);
    assert!(data.is_single());
    assert!(!data.is_multiple());
}

#[test]
fn test_response_data_multiple() {
    let users = vec![
        User {
            id: 1,
            name: "Alice".to_string(),
        },
        User {
            id: 2,
            name: "Bob".to_string(),
        },
    ];

    let data = ResponseData::multiple(users);
    let json = serde_json::to_value(&data).unwrap();

    let expected = json!([
        { "id": 1, "name": "Alice" },
        { "id": 2, "name": "Bob" }
    ]);

    assert_eq!(json, expected);
    assert!(!data.is_single());
    assert!(data.is_multiple());
}

#[test]
fn test_with_extra() {
    let user = User {
        id: 1,
        name: "Alice".to_string(),
    };

    let result: ApiResult<User> = ApiResult::value(user)
        .with_extra("timestamp", serde_json::json!(1234567890))
        .with_extra("version", serde_json::json!("1.0.0"));

    let json = serde_json::to_value(&result).unwrap();
    let expected = json!({
        "success": true,
        "data": {
            "id": 1,
            "name": "Alice"
        },
        "extra": {
            "timestamp": 1234567890,
            "version": "1.0.0"
        }
    });

    assert_eq!(json, expected);
}

#[test]
fn test_api_error_clone_partial_eq() {
    let err1 = anycms_core::ApiError::not_found("test");
    let err2 = err1.clone();
    assert_eq!(err1, err2);
}

#[test]
fn test_from_result() {
    let ok: Result<String, &str> = Ok("hello".to_string());
    let result: ApiResult<String> = ApiResult::from_result(ok);
    assert!(result.success);
    assert!(result.data.unwrap().is_single());

    let err: Result<String, &str> = Err("something failed");
    let result: ApiResult<String> = ApiResult::from_result(err);
    assert!(!result.success);
    assert_eq!(result.code.unwrap(), 500);
}

#[test]
fn test_validation_errors() {
    let result: ApiResult<User> = ApiResult::validation_errors(vec![
        FieldError::new("email", "invalid format"),
        FieldError::new("name", "required"),
    ]);

    assert!(!result.success);
    assert_eq!(result.code.unwrap(), 422);
    assert_eq!(result.message.as_ref().unwrap(), "Validation failed");

    let json = serde_json::to_value(&result).unwrap();
    let expected = json!({
        "success": false,
        "message": "Validation failed",
        "code": 422,
        "errors": [
            { "field": "email", "message": "invalid format" },
            { "field": "name", "message": "required" }
        ]
    });
    assert_eq!(json, expected);
}

#[test]
fn test_with_error_builder() {
    let result: ApiResult<User> = ApiResult::fail("Validation failed")
        .with_code(422)
        .with_error("email", "invalid format")
        .with_error("name", "required");

    let errors = result.errors.unwrap();
    assert_eq!(errors.len(), 2);
    assert_eq!(errors[0].field, "email");
    assert_eq!(errors[1].field, "name");
}

#[test]
fn test_trace_id() {
    let result: ApiResult<User> = ApiResult::fail("Not found")
        .with_code(404)
        .with_trace_id("req-abc123");

    assert_eq!(result.trace_id.as_ref().unwrap(), "req-abc123");

    let json = serde_json::to_value(&result).unwrap();
    assert_eq!(json["traceId"], "req-abc123");

    // success response without trace_id should not include the field
    let ok_result: ApiResult<()> = ApiResult::ok();
    let ok_json = serde_json::to_value(&ok_result).unwrap();
    assert!(ok_json.get("traceId").is_none());
}

#[test]
fn test_response_data_from_single() {
    let user = User { id: 1, name: "Alice".to_string() };
    let data: ResponseData<User> = user.into();
    assert!(data.is_single());
}

#[test]
fn test_response_data_from_vec() {
    let users = vec![User { id: 1, name: "Alice".to_string() }];
    let data: ResponseData<User> = users.into();
    assert!(data.is_multiple());
}