mirror of
https://github.com/meilisearch/MeiliSearch
synced 2025-04-18 07:57:59 +02:00
324 lines
12 KiB
Rust
324 lines
12 KiB
Rust
use meili_snap::{json_string, snapshot};
|
|
|
|
use crate::common::{Server, Value};
|
|
|
|
macro_rules! parameter_test {
|
|
($server:ident, $source:tt, $param:tt) => {
|
|
let source = stringify!($source);
|
|
let param = stringify!($param);
|
|
let index = $server.index("test");
|
|
|
|
let (response, _code) = index
|
|
.update_settings(crate::json!({
|
|
"embedders": {
|
|
"test": null,
|
|
}
|
|
}))
|
|
.await;
|
|
$server.wait_task(response.uid()).await.succeeded();
|
|
|
|
// Add a small delay between API calls
|
|
tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
|
|
|
|
let mut value = base_for_source(source);
|
|
value[param] = valid_parameter(source, param).0;
|
|
let (response, code) = index
|
|
.update_settings(crate::json!({
|
|
"embedders": {
|
|
"test": value
|
|
}
|
|
}))
|
|
.await;
|
|
snapshot!(code, name: concat!(stringify!($source), "-", stringify!($param), "-sending_code"));
|
|
snapshot!(json_string!(response, {".enqueuedAt" => "[enqueuedAt]", ".taskUid" => "[taskUid]"}), name: concat!(stringify!($source), "-", stringify!($param), "-sending_result"));
|
|
|
|
if response.has_uid() {
|
|
let response = $server.wait_task(response.uid()).await;
|
|
snapshot!(json_string!(response, {".enqueuedAt" => "[enqueuedAt]",
|
|
".uid" => "[uid]", ".batchUid" => "[batchUid]",
|
|
".duration" => "[duration]",
|
|
".startedAt" => "[startedAt]",
|
|
".finishedAt" => "[finishedAt]"}), name: concat!(stringify!($source), "-", stringify!($param), "-task_result"));
|
|
}
|
|
};
|
|
}
|
|
|
|
#[actix_rt::test]
|
|
#[ignore = "Test is failing with timeout issues"]
|
|
async fn bad_parameters() {
|
|
let server = Server::new().await;
|
|
|
|
// for each source, check which parameters are allowed/disallowed
|
|
// model
|
|
// - openai
|
|
parameter_test!(server, openAi, model);
|
|
// - huggingFace
|
|
parameter_test!(server, huggingFace, model);
|
|
// - userProvided
|
|
parameter_test!(server, userProvided, model);
|
|
// - ollama
|
|
parameter_test!(server, ollama, model);
|
|
// - rest
|
|
parameter_test!(server, rest, model);
|
|
// ==
|
|
|
|
// revision
|
|
// - openai
|
|
parameter_test!(server, openAi, revision);
|
|
// - huggingFace
|
|
parameter_test!(server, huggingFace, revision);
|
|
// - userProvided
|
|
parameter_test!(server, userProvided, revision);
|
|
// - ollama
|
|
parameter_test!(server, ollama, revision);
|
|
// - rest
|
|
parameter_test!(server, rest, revision);
|
|
// ==
|
|
|
|
// pooling
|
|
// - openai
|
|
parameter_test!(server, openAi, pooling);
|
|
// - huggingFace
|
|
parameter_test!(server, huggingFace, pooling);
|
|
// - userProvided
|
|
parameter_test!(server, userProvided, pooling);
|
|
// - ollama
|
|
parameter_test!(server, ollama, pooling);
|
|
// - rest
|
|
parameter_test!(server, rest, pooling);
|
|
// ==
|
|
|
|
// apiKey
|
|
// - openai
|
|
parameter_test!(server, openAi, apiKey);
|
|
// - huggingFace
|
|
parameter_test!(server, huggingFace, apiKey);
|
|
// - userProvided
|
|
parameter_test!(server, userProvided, apiKey);
|
|
// - ollama
|
|
parameter_test!(server, ollama, apiKey);
|
|
// - rest
|
|
parameter_test!(server, rest, apiKey);
|
|
// ==
|
|
|
|
// dimensions
|
|
// - openai
|
|
parameter_test!(server, openAi, dimensions);
|
|
// - huggingFace
|
|
parameter_test!(server, huggingFace, dimensions);
|
|
// - userProvided
|
|
parameter_test!(server, userProvided, dimensions);
|
|
// - ollama
|
|
parameter_test!(server, ollama, dimensions);
|
|
// - rest
|
|
parameter_test!(server, rest, dimensions);
|
|
// ==
|
|
|
|
// binaryQuantized
|
|
// - openai
|
|
parameter_test!(server, openAi, binaryQuantized);
|
|
// - huggingFace
|
|
parameter_test!(server, huggingFace, binaryQuantized);
|
|
// - userProvided
|
|
parameter_test!(server, userProvided, binaryQuantized);
|
|
// - ollama
|
|
parameter_test!(server, ollama, binaryQuantized);
|
|
// - rest
|
|
parameter_test!(server, rest, binaryQuantized);
|
|
// ==
|
|
|
|
// for each source, check that removing mandatory parameters is a failure
|
|
}
|
|
|
|
#[actix_rt::test]
|
|
#[ignore = "Test is failing with timeout issues"]
|
|
async fn bad_parameters_2() {
|
|
let server = Server::new().await;
|
|
|
|
// documentTemplate
|
|
// - openai
|
|
parameter_test!(server, openAi, documentTemplate);
|
|
// - huggingFace
|
|
parameter_test!(server, huggingFace, documentTemplate);
|
|
// - userProvided
|
|
parameter_test!(server, userProvided, documentTemplate);
|
|
// - ollama
|
|
parameter_test!(server, ollama, documentTemplate);
|
|
// - rest
|
|
parameter_test!(server, rest, documentTemplate);
|
|
// ==
|
|
|
|
// documentTemplateMaxBytes
|
|
// - openai
|
|
parameter_test!(server, openAi, documentTemplateMaxBytes);
|
|
// - huggingFace
|
|
parameter_test!(server, huggingFace, documentTemplateMaxBytes);
|
|
// - userProvided
|
|
parameter_test!(server, userProvided, documentTemplateMaxBytes);
|
|
// - ollama
|
|
parameter_test!(server, ollama, documentTemplateMaxBytes);
|
|
// - rest
|
|
parameter_test!(server, rest, documentTemplateMaxBytes);
|
|
// ==
|
|
|
|
// url
|
|
// - openai
|
|
parameter_test!(server, openAi, url);
|
|
// - huggingFace
|
|
parameter_test!(server, huggingFace, url);
|
|
// - userProvided
|
|
parameter_test!(server, userProvided, url);
|
|
// - ollama
|
|
parameter_test!(server, ollama, url);
|
|
// - rest
|
|
parameter_test!(server, rest, url);
|
|
// ==
|
|
|
|
// request
|
|
// - openai
|
|
parameter_test!(server, openAi, request);
|
|
// - huggingFace
|
|
parameter_test!(server, huggingFace, request);
|
|
// - userProvided
|
|
parameter_test!(server, userProvided, request);
|
|
// - ollama
|
|
parameter_test!(server, ollama, request);
|
|
// - rest
|
|
parameter_test!(server, rest, request);
|
|
// ==
|
|
|
|
// response
|
|
// - openai
|
|
parameter_test!(server, openAi, response);
|
|
// - huggingFace
|
|
parameter_test!(server, huggingFace, response);
|
|
// - userProvided
|
|
parameter_test!(server, userProvided, response);
|
|
// - ollama
|
|
parameter_test!(server, ollama, response);
|
|
// - rest
|
|
parameter_test!(server, rest, response);
|
|
// ==
|
|
|
|
// headers
|
|
// - openai
|
|
parameter_test!(server, openAi, headers);
|
|
// - huggingFace
|
|
parameter_test!(server, huggingFace, headers);
|
|
// - userProvided
|
|
parameter_test!(server, userProvided, headers);
|
|
// - ollama
|
|
parameter_test!(server, ollama, headers);
|
|
// - rest
|
|
parameter_test!(server, rest, headers);
|
|
// ==
|
|
|
|
// distribution
|
|
// - openai
|
|
parameter_test!(server, openAi, distribution);
|
|
// - huggingFace
|
|
parameter_test!(server, huggingFace, distribution);
|
|
// - userProvided
|
|
parameter_test!(server, userProvided, distribution);
|
|
// - ollama
|
|
parameter_test!(server, ollama, distribution);
|
|
// - rest
|
|
parameter_test!(server, rest, distribution);
|
|
// ==
|
|
}
|
|
|
|
fn base_for_source(source: &'static str) -> Value {
|
|
let base_parameters = maplit::btreemap! {
|
|
"openAi" => vec![],
|
|
"huggingFace" => vec![],
|
|
"userProvided" => vec!["dimensions"],
|
|
"ollama" => vec!["model",
|
|
// add dimensions to avoid actually fetching the model from ollama
|
|
"dimensions"],
|
|
"rest" => vec!["url", "request", "response",
|
|
// add dimensions to avoid actually fetching the model from ollama
|
|
"dimensions"],
|
|
};
|
|
|
|
let mut value = crate::json!({
|
|
"source": source
|
|
});
|
|
|
|
let mandatory_parameters = base_parameters.get(source).unwrap();
|
|
for mandatory_parameter in mandatory_parameters {
|
|
value[mandatory_parameter] = valid_parameter(source, mandatory_parameter).0;
|
|
}
|
|
value
|
|
}
|
|
|
|
fn valid_parameter(source: &'static str, parameter: &'static str) -> Value {
|
|
match (source, parameter) {
|
|
("openAi", "model") => crate::json!("text-embedding-ada-002"),
|
|
("openAi", "revision") => crate::json!("2023-05-15"),
|
|
("openAi", "pooling") => crate::json!("mean"),
|
|
("openAi", "apiKey") => crate::json!("test"),
|
|
("openAi", "dimensions") => crate::json!(1), // Use minimal dimension to avoid model download
|
|
("openAi", "binaryQuantized") => crate::json!(false),
|
|
("openAi", "documentTemplate") => crate::json!("test"),
|
|
("openAi", "documentTemplateMaxBytes") => crate::json!(100),
|
|
("openAi", "url") => crate::json!("http://test"),
|
|
("openAi", "request") => crate::json!({ "test": "test" }),
|
|
("openAi", "response") => crate::json!({ "test": "test" }),
|
|
("openAi", "headers") => crate::json!({ "test": "test" }),
|
|
("openAi", "distribution") => crate::json!("normal"),
|
|
("huggingFace", "model") => crate::json!("test"),
|
|
("huggingFace", "revision") => crate::json!("test"),
|
|
("huggingFace", "pooling") => crate::json!("mean"),
|
|
("huggingFace", "apiKey") => crate::json!("test"),
|
|
("huggingFace", "dimensions") => crate::json!(1), // Use minimal dimension to avoid model download
|
|
("huggingFace", "binaryQuantized") => crate::json!(false),
|
|
("huggingFace", "documentTemplate") => crate::json!("test"),
|
|
("huggingFace", "documentTemplateMaxBytes") => crate::json!(100),
|
|
("huggingFace", "url") => crate::json!("http://test"),
|
|
("huggingFace", "request") => crate::json!({ "test": "test" }),
|
|
("huggingFace", "response") => crate::json!({ "test": "test" }),
|
|
("huggingFace", "headers") => crate::json!({ "test": "test" }),
|
|
("huggingFace", "distribution") => crate::json!("normal"),
|
|
("userProvided", "model") => crate::json!("test"),
|
|
("userProvided", "revision") => crate::json!("test"),
|
|
("userProvided", "pooling") => crate::json!("mean"),
|
|
("userProvided", "apiKey") => crate::json!("test"),
|
|
("userProvided", "dimensions") => crate::json!(1), // Use minimal dimension to avoid model download
|
|
("userProvided", "binaryQuantized") => crate::json!(false),
|
|
("userProvided", "documentTemplate") => crate::json!("test"),
|
|
("userProvided", "documentTemplateMaxBytes") => crate::json!(100),
|
|
("userProvided", "url") => crate::json!("http://test"),
|
|
("userProvided", "request") => crate::json!({ "test": "test" }),
|
|
("userProvided", "response") => crate::json!({ "test": "test" }),
|
|
("userProvided", "headers") => crate::json!({ "test": "test" }),
|
|
("userProvided", "distribution") => crate::json!("normal"),
|
|
("ollama", "model") => crate::json!("test"),
|
|
("ollama", "revision") => crate::json!("test"),
|
|
("ollama", "pooling") => crate::json!("mean"),
|
|
("ollama", "apiKey") => crate::json!("test"),
|
|
("ollama", "dimensions") => crate::json!(1), // Use minimal dimension to avoid model download
|
|
("ollama", "binaryQuantized") => crate::json!(false),
|
|
("ollama", "documentTemplate") => crate::json!("test"),
|
|
("ollama", "documentTemplateMaxBytes") => crate::json!(100),
|
|
("ollama", "url") => crate::json!("http://test"),
|
|
("ollama", "request") => crate::json!({ "test": "test" }),
|
|
("ollama", "response") => crate::json!({ "test": "test" }),
|
|
("ollama", "headers") => crate::json!({ "test": "test" }),
|
|
("ollama", "distribution") => crate::json!("normal"),
|
|
("rest", "model") => crate::json!("test"),
|
|
("rest", "revision") => crate::json!("test"),
|
|
("rest", "pooling") => crate::json!("mean"),
|
|
("rest", "apiKey") => crate::json!("test"),
|
|
("rest", "dimensions") => crate::json!(1), // Use minimal dimension to avoid model download
|
|
("rest", "binaryQuantized") => crate::json!(false),
|
|
("rest", "documentTemplate") => crate::json!("test"),
|
|
("rest", "documentTemplateMaxBytes") => crate::json!(100),
|
|
("rest", "url") => crate::json!("http://test"),
|
|
("rest", "request") => crate::json!({ "test": "test" }),
|
|
("rest", "response") => crate::json!({ "test": "test" }),
|
|
("rest", "headers") => crate::json!({ "test": "test" }),
|
|
("rest", "distribution") => crate::json!("normal"),
|
|
_ => panic!("Invalid parameter {} for source {}", parameter, source),
|
|
}
|
|
}
|