1177 lines
38 KiB
Rust
1177 lines
38 KiB
Rust
use super::common::{self, Format, Socket, DB, NS, PASS, USER};
|
|
use serde_json::json;
|
|
use std::time::Duration;
|
|
use test_log::test;
|
|
use ulid::Ulid;
|
|
|
|
#[test(tokio::test)]
|
|
async fn ping() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Send INFO command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "ping",
|
|
}),
|
|
)
|
|
.await;
|
|
assert!(res.is_ok(), "result: {:?}", res);
|
|
let res = res.unwrap();
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
let res = res.as_object().unwrap();
|
|
assert!(res.keys().all(|k| ["id", "result"].contains(&k.as_str())), "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn info() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Define a user table
|
|
socket.send_message_query(FORMAT, "DEFINE TABLE user PERMISSIONS FULL").await?;
|
|
// Define a user scope
|
|
socket
|
|
.send_message_query(
|
|
FORMAT,
|
|
r#"
|
|
DEFINE SCOPE scope SESSION 24h
|
|
SIGNUP ( CREATE user SET user = $user, pass = crypto::argon2::generate($pass) )
|
|
SIGNIN ( SELECT * FROM user WHERE user = $user AND crypto::argon2::compare(pass, $pass) )
|
|
;
|
|
"#,
|
|
)
|
|
.await?;
|
|
// Create a user record
|
|
socket
|
|
.send_message_query(
|
|
FORMAT,
|
|
r#"
|
|
CREATE user CONTENT {
|
|
user: 'user',
|
|
pass: crypto::argon2::generate('pass')
|
|
};
|
|
"#,
|
|
)
|
|
.await?;
|
|
// Sign in as scope user
|
|
socket.send_message_signin(FORMAT, "user", "pass", Some(NS), Some(DB), Some("scope")).await?;
|
|
// Send INFO command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "info",
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert_eq!(res["user"], "user", "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn signup() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Setup the scope
|
|
socket
|
|
.send_message_query(
|
|
FORMAT,
|
|
r#"
|
|
DEFINE SCOPE scope SESSION 24h
|
|
SIGNUP ( CREATE user SET email = $email, pass = crypto::argon2::generate($pass) )
|
|
SIGNIN ( SELECT * FROM user WHERE email = $email AND crypto::argon2::compare(pass, $pass) )
|
|
;"#,
|
|
)
|
|
.await?;
|
|
// Send SIGNUP command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "signup",
|
|
"params": [{
|
|
"ns": NS,
|
|
"db": DB,
|
|
"sc": "scope",
|
|
"email": "email@email.com",
|
|
"pass": "pass",
|
|
}],
|
|
}),
|
|
)
|
|
.await;
|
|
assert!(res.is_ok(), "result: {:?}", res);
|
|
let res = res.unwrap();
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
let res = res.as_object().unwrap();
|
|
// Verify response contains no error
|
|
assert!(res.keys().all(|k| ["id", "result"].contains(&k.as_str())), "result: {:?}", res);
|
|
// Verify it returns a token
|
|
assert!(res["result"].is_string(), "result: {:?}", res);
|
|
let res = res["result"].as_str().unwrap();
|
|
assert!(res.starts_with("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9"), "result: {}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn signin() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Setup the scope
|
|
socket
|
|
.send_message_query(
|
|
FORMAT,
|
|
r#"
|
|
DEFINE SCOPE scope SESSION 24h
|
|
SIGNUP ( CREATE user SET email = $email, pass = crypto::argon2::generate($pass) )
|
|
SIGNIN ( SELECT * FROM user WHERE email = $email AND crypto::argon2::compare(pass, $pass) )
|
|
;"#,
|
|
)
|
|
.await?;
|
|
// Send SIGNUP command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "signup",
|
|
"params": [{
|
|
"ns": NS,
|
|
"db": DB,
|
|
"sc": "scope",
|
|
"email": "email@email.com",
|
|
"pass": "pass",
|
|
}],
|
|
}),
|
|
)
|
|
.await;
|
|
assert!(res.is_ok(), "result: {:?}", res);
|
|
let res = res.unwrap();
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
let res = res.as_object().unwrap();
|
|
// Verify response contains no error
|
|
assert!(res.keys().all(|k| ["id", "result"].contains(&k.as_str())), "result: {:?}", res);
|
|
// Verify it returns a token
|
|
assert!(res["result"].is_string(), "result: {:?}", res);
|
|
let res = res["result"].as_str().unwrap();
|
|
assert!(res.starts_with("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9"), "result: {}", res);
|
|
// Send SIGNIN command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "signin",
|
|
"params": [{
|
|
"ns": NS,
|
|
"db": DB,
|
|
"sc": "scope",
|
|
"email": "email@email.com",
|
|
"pass": "pass",
|
|
}],
|
|
}),
|
|
)
|
|
.await;
|
|
assert!(res.is_ok(), "result: {:?}", res);
|
|
let res = res.unwrap();
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
let res = res.as_object().unwrap();
|
|
// Verify response contains no error
|
|
assert!(res.keys().all(|k| ["id", "result"].contains(&k.as_str())), "result: {:?}", res);
|
|
// Verify it returns a token
|
|
assert!(res["result"].is_string(), "result: {:?}", res);
|
|
let res = res["result"].as_str().unwrap();
|
|
assert!(res.starts_with("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9"), "result: {}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn invalidate() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Verify we have an authenticated session
|
|
let res = socket.send_message_query(FORMAT, "DEFINE NAMESPACE test").await?;
|
|
assert_eq!(res[0]["status"], "OK", "result: {:?}", res);
|
|
// Send INVALIDATE command
|
|
socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "invalidate",
|
|
}),
|
|
)
|
|
.await?;
|
|
// Verify we have an invalidated session
|
|
let res = socket.send_message_query(FORMAT, "DEFINE NAMESPACE test").await?;
|
|
assert_eq!(res[0]["status"], "ERR", "result: {:?}", res);
|
|
assert_eq!(
|
|
res[0]["result"], "IAM error: Not enough permissions to perform this action",
|
|
"result: {:?}",
|
|
res
|
|
);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn authenticate() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
let token = socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Disconnect the connection
|
|
socket.close().await?;
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Send AUTHENTICATE command
|
|
socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "authenticate",
|
|
"params": [
|
|
token,
|
|
],
|
|
}),
|
|
)
|
|
.await?;
|
|
// Verify we have an authenticated session
|
|
let res = socket.send_message_query(FORMAT, "DEFINE NAMESPACE test").await?;
|
|
assert_eq!(res[0]["status"], "OK", "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn letset() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Send LET command
|
|
socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "let",
|
|
"params": [
|
|
"let_var", "let_value",
|
|
],
|
|
}),
|
|
)
|
|
.await?;
|
|
// Send SET command
|
|
socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "set",
|
|
"params": [
|
|
"set_var", "set_value",
|
|
],
|
|
}),
|
|
)
|
|
.await?;
|
|
// Verify the variables are set
|
|
let res = socket.send_message_query(FORMAT, "SELECT * FROM $let_var, $set_var").await?;
|
|
assert_eq!(res[0]["result"], json!(["let_value", "set_value"]), "result: {:?}", res);
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn unset() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Send LET command
|
|
socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "let",
|
|
"params": [
|
|
"let_var", "let_value",
|
|
],
|
|
}),
|
|
)
|
|
.await?;
|
|
// Verify the variable is set
|
|
let res = socket.send_message_query(FORMAT, "SELECT * FROM $let_var").await?;
|
|
assert_eq!(res[0]["result"], json!(["let_value"]), "result: {:?}", res);
|
|
// Send UNSET command
|
|
socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "unset",
|
|
"params": [
|
|
"let_var",
|
|
],
|
|
}),
|
|
)
|
|
.await?;
|
|
// Verify the variable is unset
|
|
let res = socket.send_message_query(FORMAT, "SELECT * FROM $let_var").await?;
|
|
assert_eq!(res[0]["result"], json!([null]), "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn select() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Create a test record
|
|
socket.send_message_query(FORMAT, "CREATE tester SET name = 'foo', value = 'bar'").await?;
|
|
// Send SELECT command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "select",
|
|
"params": [
|
|
"tester",
|
|
],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert_eq!(res[0]["name"], "foo", "result: {:?}", res);
|
|
assert_eq!(res[0]["value"], "bar", "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn insert() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Send INSERT command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "insert",
|
|
"params": [
|
|
"tester",
|
|
{
|
|
"name": "foo",
|
|
"value": "bar",
|
|
}
|
|
],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert_eq!(res[0]["name"], "foo", "result: {:?}", res);
|
|
assert_eq!(res[0]["value"], "bar", "result: {:?}", res);
|
|
// Verify the data was inserted and can be queried
|
|
let res = socket.send_message_query(FORMAT, "SELECT * FROM tester").await?;
|
|
assert!(res[0]["result"].is_array(), "result: {:?}", res);
|
|
let res = res[0]["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert_eq!(res[0]["name"], "foo", "result: {:?}", res);
|
|
assert_eq!(res[0]["value"], "bar", "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn create() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Send CREATE command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "create",
|
|
"params": [
|
|
"tester",
|
|
{
|
|
"value": "bar",
|
|
}
|
|
],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert_eq!(res[0]["value"], "bar", "result: {:?}", res);
|
|
// Verify the data was created
|
|
let res = socket.send_message_query(FORMAT, "SELECT * FROM tester").await?;
|
|
assert!(res[0]["result"].is_array(), "result: {:?}", res);
|
|
let res = res[0]["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert_eq!(res[0]["value"], "bar", "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn update() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Create a test record
|
|
socket.send_message_query(FORMAT, "CREATE tester SET name = 'foo'").await?;
|
|
// Send UPDATE command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "update",
|
|
"params": [
|
|
"tester",
|
|
{
|
|
"value": "bar",
|
|
}
|
|
],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert_eq!(res[0]["value"], "bar", "result: {:?}", res);
|
|
// Verify the data was updated
|
|
let res = socket.send_message_query(FORMAT, "SELECT * FROM tester").await?;
|
|
assert!(res[0]["result"].is_array(), "result: {:?}", res);
|
|
let res = res[0]["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert_eq!(res[0]["name"], json!(null), "result: {:?}", res);
|
|
assert_eq!(res[0]["value"], "bar", "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn merge() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Create a test record
|
|
socket.send_message_query(FORMAT, "CREATE tester SET name = 'foo'").await?;
|
|
// Send UPDATE command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "merge",
|
|
"params": [
|
|
"tester",
|
|
{
|
|
"value": "bar",
|
|
}
|
|
],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert_eq!(res[0]["name"], "foo", "result: {:?}", res);
|
|
assert_eq!(res[0]["value"], "bar", "result: {:?}", res);
|
|
// Verify the data was merged
|
|
let res = socket.send_message_query(FORMAT, "SELECT * FROM tester").await?;
|
|
assert!(res[0]["result"].is_array(), "result: {:?}", res);
|
|
let res = res[0]["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert_eq!(res[0]["name"], "foo", "result: {:?}", res);
|
|
assert_eq!(res[0]["value"], "bar", "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn patch() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Create a test record
|
|
socket.send_message_query(FORMAT, "CREATE tester:id SET name = 'foo'").await?;
|
|
// Send PATCH command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "patch",
|
|
"params": [
|
|
"tester:id",
|
|
[
|
|
{
|
|
"op": "add",
|
|
"path": "value",
|
|
"value": "bar"
|
|
},
|
|
{
|
|
"op": "remove",
|
|
"path": "name",
|
|
}
|
|
]
|
|
]
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert_eq!(res.get("value"), Some(json!("bar")).as_ref(), "result: {:?}", res);
|
|
// Verify the data was patched
|
|
let res = socket.send_message_query(FORMAT, "SELECT * FROM tester").await?;
|
|
assert!(res[0]["result"].is_array(), "result: {:?}", res);
|
|
let res = res[0]["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert_eq!(res[0]["name"], json!(null), "result: {:?}", res);
|
|
assert_eq!(res[0]["value"], "bar", "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn delete() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Create a test record
|
|
socket.send_message_query(FORMAT, "CREATE tester:id").await?;
|
|
// Send DELETE command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "delete",
|
|
"params": [
|
|
"tester"
|
|
]
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert_eq!(res[0]["id"], "tester:id", "result: {:?}", res);
|
|
// Create a test record
|
|
socket.send_message_query(FORMAT, "CREATE tester:id").await?;
|
|
// Send DELETE command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "delete",
|
|
"params": [
|
|
"tester:id"
|
|
]
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert_eq!(res["id"], "tester:id", "result: {:?}", res);
|
|
// Verify the data was merged
|
|
let res = socket.send_message_query(FORMAT, "SELECT * FROM tester").await?;
|
|
assert!(res[0]["result"].is_array(), "result: {:?}", res);
|
|
let res = res[0]["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 0, "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn query() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Send QUERY command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "query",
|
|
"params": [
|
|
"CREATE tester; SELECT * FROM tester;",
|
|
]
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 2, "result: {:?}", res);
|
|
// Verify the data was created
|
|
let res = socket.send_message_query(FORMAT, "SELECT * FROM tester").await?;
|
|
assert!(res[0]["result"].is_array(), "result: {:?}", res);
|
|
let res = res[0]["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn version() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Send version command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "version",
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res["result"].is_string(), "result: {:?}", res);
|
|
let res = res["result"].as_str().unwrap();
|
|
assert!(res.starts_with("surrealdb-"), "result: {}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
// Validate that the WebSocket is able to process multiple queries concurrently
|
|
#[test(tokio::test)]
|
|
async fn concurrency() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Send 5 long-running queries and verify they run concurrently
|
|
for i in 0..5 {
|
|
socket
|
|
.send_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "query",
|
|
"params": [format!("SLEEP 3s; RETURN {i};")],
|
|
}),
|
|
)
|
|
.await?;
|
|
}
|
|
// Verify the queries all completed concurrently within 5 seconds
|
|
let res = socket.receive_all_messages(FORMAT, 5, Duration::from_secs(5)).await?;
|
|
assert!(res.iter().all(|v| v["error"].is_null()), "Unexpected error received: {:#?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn live() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Send LIVE command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "live",
|
|
"params": ["tester"],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_string(), "result: {:?}", res);
|
|
let live1 = res["result"].as_str().unwrap();
|
|
// Send QUERY command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "query",
|
|
"params": ["LIVE SELECT * FROM tester"],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert!(res[0]["result"].is_string(), "result: {:?}", res);
|
|
let live2 = res[0]["result"].as_str().unwrap();
|
|
// Create a new test record
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "query",
|
|
"params": ["CREATE tester:id SET name = 'foo'"],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
// Wait some time for all messages to arrive, and then search for the notification message
|
|
let msgs = socket.receive_all_messages(FORMAT, 2, Duration::from_secs(1)).await?;
|
|
assert!(msgs.iter().all(|v| v["error"].is_null()), "Unexpected error received: {:?}", msgs);
|
|
// Check for first live query notifcation
|
|
let res = msgs.iter().find(|v| common::is_notification_from_lq(v, live1));
|
|
assert!(res.is_some(), "Expected to find a notification for LQ id {}: {:?}", live1, msgs);
|
|
let res = res.unwrap();
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
let res = res.as_object().unwrap();
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert!(res["action"].is_string(), "result: {:?}", res);
|
|
assert_eq!(res["action"], "CREATE", "result: {:?}", res);
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert_eq!(res["id"], "tester:id", "result: {:?}", res);
|
|
// Check for second live query notifcation
|
|
let res = msgs.iter().find(|v| common::is_notification_from_lq(v, live2));
|
|
assert!(res.is_some(), "Expected to find a notification for LQ id {}: {:?}", live2, msgs);
|
|
let res = res.unwrap();
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
let res = res.as_object().unwrap();
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert_eq!(res["action"], "CREATE", "result: {:?}", res);
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert_eq!(res["id"], "tester:id", "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn kill() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Send LIVE command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "live",
|
|
"params": ["tester"],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_string(), "result: {:?}", res);
|
|
let live1 = res["result"].as_str().unwrap();
|
|
// Send QUERY command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "query",
|
|
"params": ["LIVE SELECT * FROM tester"],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert!(res[0]["result"].is_string(), "result: {:?}", res);
|
|
let live2 = res[0]["result"].as_str().unwrap();
|
|
// Create a new test record
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "query",
|
|
"params": ["CREATE tester:one SET name = 'one'"],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
// Wait some time for all messages to arrive, and then search for the notification message
|
|
let msgs = socket.receive_all_messages(FORMAT, 2, Duration::from_secs(1)).await?;
|
|
assert!(msgs.iter().all(|v| v["error"].is_null()), "Unexpected error received: {:?}", msgs);
|
|
// Check for first live query notifcation
|
|
let res = msgs.iter().find(|v| common::is_notification_from_lq(v, live1));
|
|
assert!(res.is_some(), "Expected to find a notification for LQ id {}: {:?}", live1, msgs);
|
|
let res = res.unwrap();
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
let res = res.as_object().unwrap();
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert!(res["action"].is_string(), "result: {:?}", res);
|
|
assert_eq!(res["action"], "CREATE", "result: {:?}", res);
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert_eq!(res["id"], "tester:one", "result: {:?}", res);
|
|
// Check for second live query notifcation
|
|
let res = msgs.iter().find(|v| common::is_notification_from_lq(v, live2));
|
|
assert!(res.is_some(), "Expected to find a notification for LQ id {}: {:?}", live2, msgs);
|
|
let res = res.unwrap();
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
let res = res.as_object().unwrap();
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert_eq!(res["action"], "CREATE", "result: {:?}", res);
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert_eq!(res["id"], "tester:one", "result: {:?}", res);
|
|
// Send KILL command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "kill",
|
|
"params": [live1],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_null(), "result: {:?}", res);
|
|
// Create a new test record
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "query",
|
|
"params": ["CREATE tester:two SET name = 'two'"],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
// Wait some time for all messages to arrive, and then search for the notification message
|
|
let msgs = socket.receive_all_messages(FORMAT, 1, Duration::from_secs(1)).await?;
|
|
assert!(msgs.iter().all(|v| v["error"].is_null()), "Unexpected error received: {:?}", msgs);
|
|
// Check for second live query notifcation
|
|
let res = msgs.iter().find(|v| common::is_notification_from_lq(v, live2));
|
|
assert!(res.is_some(), "Expected to find a notification for LQ id {}: {:?}", live2, msgs);
|
|
let res = res.unwrap();
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
let res = res.as_object().unwrap();
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert_eq!(res["action"], "CREATE", "result: {:?}", res);
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert_eq!(res["id"], "tester:two", "result: {:?}", res);
|
|
// Send QUERY command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "query",
|
|
"params": [format!("KILL '{live2}'")],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
assert!(res[0]["result"].is_null(), "result: {:?}", res);
|
|
// Create a new test record
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "query",
|
|
"params": ["CREATE tester:tre SET name = 'two'"],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
// Wait some time for all messages to arrive, and then search for the notification message
|
|
let msgs = socket.receive_all_messages(FORMAT, 0, Duration::from_secs(1)).await?;
|
|
assert!(msgs.iter().all(|v| v["error"].is_null()), "Unexpected error received: {:?}", msgs);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn live_second_connection() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket1 = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket1.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket1.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Send LIVE command
|
|
let res = socket1
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "live",
|
|
"params": ["tester"],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_string(), "result: {:?}", res);
|
|
let liveid = res["result"].as_str().unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket2 = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket2.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket2.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Create a new test record
|
|
let res = socket2
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "query",
|
|
"params": ["CREATE tester:id SET name = 'foo'"],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
// Wait some time for all messages to arrive, and then search for the notification message
|
|
let msgs = socket1.receive_all_messages(FORMAT, 1, Duration::from_secs(1)).await?;
|
|
assert!(msgs.iter().all(|v| v["error"].is_null()), "Unexpected error received: {:?}", msgs);
|
|
// Check for live query notifcation
|
|
let res = msgs.iter().find(|v| common::is_notification_from_lq(v, liveid));
|
|
assert!(res.is_some(), "Expected to find a notification for LQ id {}: {:?}", liveid, msgs);
|
|
let res = res.unwrap();
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
let res = res.as_object().unwrap();
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert!(res["action"].is_string(), "result: {:?}", res);
|
|
assert_eq!(res["action"], "CREATE", "result: {:?}", res);
|
|
assert!(res["result"].is_object(), "result: {:?}", res);
|
|
let res = res["result"].as_object().unwrap();
|
|
assert_eq!(res["id"], "tester:id", "result: {:?}", res);
|
|
// Test passed
|
|
Ok(())
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn variable_auth_live_query() -> Result<(), Box<dyn std::error::Error>> {
|
|
// Setup database server
|
|
let (addr, _server) = common::start_server_with_defaults().await.unwrap();
|
|
// Connect to WebSocket
|
|
let mut socket = Socket::connect(&addr, SERVER).await?;
|
|
// Authenticate the connection
|
|
socket.send_message_signin(FORMAT, USER, PASS, None, None, None).await?;
|
|
// Specify a namespace and database
|
|
socket.send_message_use(FORMAT, Some(NS), Some(DB)).await?;
|
|
// Setup the scope
|
|
socket
|
|
.send_message_query(
|
|
FORMAT,
|
|
r#"
|
|
DEFINE SCOPE scope SESSION 1s
|
|
SIGNUP ( CREATE user SET email = $email, pass = crypto::argon2::generate($pass) )
|
|
SIGNIN ( SELECT * FROM user WHERE email = $email AND crypto::argon2::compare(pass, $pass) )
|
|
;"#,
|
|
)
|
|
.await?;
|
|
// Send SIGNUP command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "signup",
|
|
"params": [{
|
|
"ns": NS,
|
|
"db": DB,
|
|
"sc": "scope",
|
|
"email": "email@email.com",
|
|
"pass": "pass",
|
|
}],
|
|
}),
|
|
)
|
|
.await;
|
|
assert!(res.is_ok(), "result: {:?}", res);
|
|
let res = res.unwrap();
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
let res = res.as_object().unwrap();
|
|
// Verify response contains no error
|
|
assert!(res.keys().all(|k| ["id", "result"].contains(&k.as_str())), "result: {:?}", res);
|
|
// Send LIVE command
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "live",
|
|
"params": ["tester"],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_string(), "result: {:?}", res);
|
|
// Wait 2 seconds for auth to expire
|
|
tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
|
|
// Create a new test record
|
|
let res = socket
|
|
.send_and_receive_message(
|
|
FORMAT,
|
|
json!({
|
|
"id": Ulid::new(),
|
|
"method": "query",
|
|
"params": ["CREATE tester:id SET name = 'foo'"],
|
|
}),
|
|
)
|
|
.await?;
|
|
assert!(res.is_object(), "result: {:?}", res);
|
|
assert!(res["result"].is_array(), "result: {:?}", res);
|
|
let res = res["result"].as_array().unwrap();
|
|
assert_eq!(res.len(), 1, "result: {:?}", res);
|
|
// Wait some time for all messages to arrive, and then search for the notification message
|
|
let msgs = socket.receive_all_messages(FORMAT, 0, Duration::from_secs(1)).await?;
|
|
assert!(msgs.iter().all(|v| v["error"].is_null()), "Unexpected error received: {:?}", msgs);
|
|
// Test passed
|
|
Ok(())
|
|
}
|