use zilliz::model::loader::ModelLoader;
mod control_plane {
use super::*;
fn load() -> zilliz::model::loader::Models {
ModelLoader::load_builtin().expect("Failed to load models")
}
#[test]
fn test_load_control_plane() {
let models = load();
assert!(models.control_plane.resources.contains_key("cluster"));
assert!(models.control_plane.resources.contains_key("project"));
assert!(models.control_plane.endpoint.is_some());
assert_eq!(
models.control_plane.endpoint.as_deref(),
Some("https://api.cloud.zilliz.com")
);
}
#[test]
fn test_cluster_operations() {
let models = load();
let cluster = &models.control_plane.resources["cluster"];
for op in &["list", "describe", "delete", "suspend", "resume", "modify", "providers", "regions"] {
assert!(
cluster.operations.contains_key(*op),
"Missing cluster operation: {}",
op
);
}
}
#[test]
fn test_project_operations() {
let models = load();
let project = &models.control_plane.resources["project"];
for op in &["list", "describe", "create", "upgrade"] {
assert!(
project.operations.contains_key(*op),
"Missing project operation: {}",
op
);
}
}
#[test]
fn test_backup_operations() {
let models = load();
assert!(models.control_plane.resources.contains_key("backup"));
let backup = &models.control_plane.resources["backup"];
for op in &[
"create", "list", "describe", "delete", "export",
"restore-cluster", "restore-collection",
"describe-policy", "update-policy",
] {
assert!(
backup.operations.contains_key(*op),
"Missing backup operation: {}",
op
);
}
}
#[test]
fn test_import_operations() {
let models = load();
assert!(models.control_plane.resources.contains_key("import"));
let import = &models.control_plane.resources["import"];
for op in &["start", "list", "status"] {
assert!(
import.operations.contains_key(*op),
"Missing import operation: {}",
op
);
}
}
#[test]
fn test_backup_describe_has_two_path_params() {
let models = load();
let describe = &models.control_plane.resources["backup"].operations["describe"];
let path_params: Vec<&str> = describe
.params
.iter()
.filter(|p| p.is_path_param())
.map(|p| p.name.as_str())
.collect();
assert_eq!(path_params.len(), 2);
assert!(path_params.contains(&"clusterId"));
assert!(path_params.contains(&"backupId"));
}
#[test]
fn test_project_upgrade_uses_patch() {
let models = load();
let upgrade = &models.control_plane.resources["project"].operations["upgrade"];
assert_eq!(upgrade.method(), "PATCH");
}
#[test]
fn test_auth_config_present() {
let models = load();
let auth = models.control_plane.auth.as_ref().expect("Auth config should be present");
assert!(!auth.auth0_domain.is_empty());
assert!(!auth.client_id.is_empty());
assert!(!auth.login_api.is_empty());
}
}
mod data_plane {
use super::*;
fn load() -> zilliz::model::loader::Models {
ModelLoader::load_builtin().expect("Failed to load models")
}
#[test]
fn test_load_data_plane() {
let models = load();
assert!(models.data_plane.resources.contains_key("collection"));
assert!(models.data_plane.resources.contains_key("vector"));
assert!(models.data_plane.endpoint.is_none());
}
#[test]
fn test_collection_operations() {
let models = load();
let collection = &models.data_plane.resources["collection"];
for op in &[
"list", "describe", "create", "drop", "has", "rename",
"load", "release", "get-stats", "get-load-state", "flush", "compact",
] {
assert!(
collection.operations.contains_key(*op),
"Missing collection operation: {}",
op
);
}
}
#[test]
fn test_vector_operations() {
let models = load();
let vector = &models.data_plane.resources["vector"];
for op in &["search", "hybrid-search", "query", "insert", "upsert", "get", "delete"] {
assert!(
vector.operations.contains_key(*op),
"Missing vector operation: {}",
op
);
}
}
#[test]
fn test_database_operations() {
let models = load();
assert!(models.data_plane.resources.contains_key("database"));
let db = &models.data_plane.resources["database"];
for op in &["create", "list", "describe", "drop"] {
assert!(db.operations.contains_key(*op), "Missing database operation: {}", op);
}
}
#[test]
fn test_index_operations() {
let models = load();
let index = &models.data_plane.resources["index"];
for op in &["create", "list", "describe", "drop"] {
assert!(index.operations.contains_key(*op), "Missing index operation: {}", op);
}
}
#[test]
fn test_partition_operations() {
let models = load();
let partition = &models.data_plane.resources["partition"];
for op in &["create", "list", "has", "get-stats", "load", "release", "drop"] {
assert!(
partition.operations.contains_key(*op),
"Missing partition operation: {}",
op
);
}
}
#[test]
fn test_user_operations() {
let models = load();
let user = &models.data_plane.resources["user"];
for op in &["create", "list", "describe", "drop", "update-password", "grant-role", "revoke-role"] {
assert!(user.operations.contains_key(*op), "Missing user operation: {}", op);
}
}
#[test]
fn test_role_operations() {
let models = load();
let role = &models.data_plane.resources["role"];
for op in &["create", "list", "describe", "drop", "grant-privilege", "revoke-privilege"] {
assert!(role.operations.contains_key(*op), "Missing role operation: {}", op);
}
}
#[test]
fn test_alias_operations() {
let models = load();
let alias = &models.data_plane.resources["alias"];
for op in &["create", "list", "describe", "alter", "drop"] {
assert!(alias.operations.contains_key(*op), "Missing alias operation: {}", op);
}
}
#[test]
fn test_collection_create_has_body_param() {
let models = load();
let create_op = &models.data_plane.resources["collection"].operations["create"];
assert_eq!(create_op.body_param.as_deref(), Some("--body"));
}
#[test]
fn test_hybrid_search_has_body_param() {
let models = load();
let hs = &models.data_plane.resources["vector"].operations["hybrid-search"];
assert_eq!(hs.body_param.as_deref(), Some("--body"));
}
#[test]
fn test_hybrid_search_has_array_and_object_params() {
let models = load();
let hs = &models.data_plane.resources["vector"].operations["hybrid-search"];
let search_param = hs.params.iter().find(|p| p.name == "search").unwrap();
let rerank_param = hs.params.iter().find(|p| p.name == "rerank").unwrap();
assert_eq!(search_param.param_type, "array");
assert_eq!(rerank_param.param_type, "object");
}
}