marine/engine/tests/redis_sqlite.rs

187 lines
5.9 KiB
Rust
Raw Normal View History

2020-05-02 15:34:48 +00:00
/*
* Copyright 2020 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
2020-08-23 22:00:38 +00:00
use fce::FCE;
use fce::IValue;
2020-05-02 15:34:48 +00:00
const REDIS_DOWNLOAD_URL: &str =
2021-04-12 12:30:37 +00:00
"https://github.com/fluencelabs/redis/releases/download/v0.12.0_w/redis.wasm";
2020-05-02 15:34:48 +00:00
const SQLITE_DOWNLOAD_URL: &str =
2021-04-12 12:30:37 +00:00
"https://github.com/fluencelabs/sqlite/releases/download/v0.12.0_w/sqlite3.wasm";
2020-05-02 15:34:48 +00:00
2020-08-23 22:00:38 +00:00
pub async fn download(url: &str) -> bytes::Bytes {
reqwest::get(url)
.await
.expect("failed to download redis")
.bytes()
.await
.expect("failed to convert response to bytes")
}
2020-05-02 15:34:48 +00:00
#[tokio::test]
async fn redis() {
2020-08-23 22:00:38 +00:00
let wasm_bytes = download(REDIS_DOWNLOAD_URL).await;
2020-05-02 15:34:48 +00:00
2020-05-08 17:38:29 +00:00
let mut fce = FCE::new();
2020-05-02 15:34:48 +00:00
let module_name = "redis";
2020-08-23 01:04:11 +00:00
let config = <_>::default();
2020-05-02 15:34:48 +00:00
2020-08-23 01:04:11 +00:00
fce.load_module(module_name, wasm_bytes.as_ref(), config)
2020-08-23 22:00:38 +00:00
.unwrap_or_else(|e| panic!("can't load a module into FCE: {:?}", e));
2020-05-02 15:34:48 +00:00
2020-05-08 17:38:29 +00:00
let result1 = fce
2020-08-23 01:33:05 +00:00
.call(
module_name,
"invoke",
&[IValue::String(String::from("SET A 10"))],
)
2020-05-02 15:34:48 +00:00
.unwrap_or_else(|e| panic!("error while FCE invocation: {:?}", e));
2020-05-08 17:38:29 +00:00
let result2 = fce
2020-08-23 01:33:05 +00:00
.call(
module_name,
"invoke",
&[IValue::String(String::from("SADD B 20"))],
)
2020-05-02 15:34:48 +00:00
.unwrap_or_else(|e| panic!("error while FCE invocation: {:?}", e));
2020-05-08 17:38:29 +00:00
let result3 = fce
2020-08-23 01:33:05 +00:00
.call(
module_name,
"invoke",
&[IValue::String(String::from("GET A"))],
)
2020-05-02 15:34:48 +00:00
.unwrap_or_else(|e| panic!("error while FCE invocation: {:?}", e));
2020-05-08 17:38:29 +00:00
let result4 = fce
2020-08-23 01:33:05 +00:00
.call(
module_name,
"invoke",
&[IValue::String(String::from("SMEMBERS B"))],
)
2020-05-02 15:34:48 +00:00
.unwrap_or_else(|e| panic!("error while FCE invocation: {:?}", e));
2020-05-08 17:38:29 +00:00
let result5 = fce
2020-08-23 01:33:05 +00:00
.call(
module_name,
"invoke",
&[IValue::String(String::from(
"eval \"redis.call('incr', 'A') return redis.call('get', 'A') * 8 + 5\" 0",
))],
)
2020-05-02 15:34:48 +00:00
.expect("error while FCE invocation");
2020-08-23 01:04:11 +00:00
assert_eq!(result1, vec![IValue::String(String::from("+OK\r\n"))]);
assert_eq!(result2, vec![IValue::String(String::from(":1\r\n"))]);
assert_eq!(result3, vec![IValue::String(String::from("$2\r\n10\r\n"))]);
2020-08-23 01:33:05 +00:00
assert_eq!(
result4,
vec![IValue::String(String::from("*1\r\n$2\r\n20\r\n"))]
);
2020-08-23 01:04:11 +00:00
assert_eq!(result5, vec![IValue::String(String::from(":93\r\n"))]);
2020-05-02 15:34:48 +00:00
}
#[tokio::test]
async fn sqlite() {
2020-08-23 22:00:38 +00:00
let wasm_bytes = download(SQLITE_DOWNLOAD_URL).await;
2020-05-02 15:34:48 +00:00
2020-05-08 17:38:29 +00:00
let mut fce = FCE::new();
2020-05-02 15:34:48 +00:00
let module_name = "sqlite";
2020-08-23 01:04:11 +00:00
let config = <_>::default();
2020-05-02 15:34:48 +00:00
2020-08-23 01:04:11 +00:00
fce.load_module(module_name, wasm_bytes.as_ref(), config)
2020-08-23 22:00:38 +00:00
.unwrap_or_else(|e| panic!("can't load a module into FCE: {:?}", e));
2020-05-02 15:34:48 +00:00
2021-03-16 10:51:59 +00:00
let mut result1 = fce
2020-08-23 01:04:11 +00:00
.call(
2020-05-02 15:34:48 +00:00
module_name,
2021-03-16 10:51:59 +00:00
"sqlite3_open_v2",
&[
IValue::String(String::from(":memory:")),
IValue::S32(6),
IValue::String(String::new()),
],
2020-05-02 15:34:48 +00:00
)
.unwrap_or_else(|e| panic!("error while FCE invocation: {:?}", e));
2021-03-16 10:51:59 +00:00
let mut record_values = match result1.remove(0) {
IValue::Record(value) => value.into_vec(),
_ => panic!("return result should have record type"),
};
let db_handle = match record_values.remove(1) {
IValue::U32(value) => value,
_ => panic!("db handle should have u32 type"),
};
let mut result1 = fce
2020-08-23 01:04:11 +00:00
.call(
2020-05-02 15:34:48 +00:00
module_name,
2021-03-16 10:51:59 +00:00
"sqlite3_exec",
&[
IValue::U32(db_handle),
IValue::String(String::from("CREATE VIRTUAL TABLE users USING FTS5(body)")),
IValue::S32(0),
IValue::S32(0),
],
2020-05-02 15:34:48 +00:00
)
.unwrap_or_else(|e| panic!("error while FCE invocation: {:?}", e));
2021-03-16 10:51:59 +00:00
let mut result2 = fce
2020-08-23 01:04:11 +00:00
.call(
2020-05-02 15:34:48 +00:00
module_name,
2021-03-16 10:51:59 +00:00
"sqlite3_exec",
&[
IValue::U32(db_handle),
IValue::String(String::from(
"INSERT INTO users(body) VALUES('AB'), ('BC'), ('CD'), ('DE')",
)),
IValue::S32(0),
IValue::S32(0),
],
2020-05-02 15:34:48 +00:00
)
.unwrap_or_else(|e| panic!("error while FCE invocation: {:?}", e));
2021-03-16 10:51:59 +00:00
let mut result3 = fce
.call(
module_name,
"sqlite3_exec",
&[
IValue::U32(db_handle),
IValue::String(String::from(
"SELECT * FROM users WHERE users MATCH 'A* OR B*'",
)),
IValue::S32(0),
IValue::S32(0),
],
)
.unwrap_or_else(|e| panic!("error while FCE invocation: {:?}", e));
let result1 = match result1.remove(0) {
IValue::Record(value) => value.into_vec(),
_ => panic!("result should have record type"),
};
assert_eq!(result1, vec![IValue::S32(0), IValue::String(String::new())]);
let result2 = match result2.remove(0) {
IValue::Record(value) => value.into_vec(),
_ => panic!("result should have record type"),
};
assert_eq!(result2, vec![IValue::S32(0), IValue::String(String::new())]);
let result3 = match result3.remove(0) {
IValue::Record(value) => value.into_vec(),
_ => panic!("result should have record type"),
};
assert_eq!(result3, vec![IValue::S32(0), IValue::String(String::new())]);
2020-05-02 15:34:48 +00:00
}