mirror of
https://codeberg.org/icewind/nextcloud-config-parser.git
synced 2026-06-03 08:34:13 +02:00
723 lines
22 KiB
Rust
723 lines
22 KiB
Rust
use nextcloud_config_parser::{
|
|
parse, parse_glob, Config, Database, DbConnect, RedisClusterConnectionInfo, RedisConfig,
|
|
RedisConnectionAddr, RedisConnectionInfo, RedisTlsParams, SslOptions,
|
|
};
|
|
use std::fmt::Debug;
|
|
|
|
use indexmap::{indexmap, IndexMap};
|
|
use redis::{ConnectionAddr, ConnectionInfo};
|
|
use sqlx::mysql::{MySqlConnectOptions, MySqlSslMode};
|
|
use sqlx::sqlite::SqliteConnectOptions;
|
|
use sqlx::{any::AnyConnectOptions, postgres::PgConnectOptions};
|
|
use std::str::FromStr;
|
|
|
|
#[cfg(test)]
|
|
#[track_caller]
|
|
fn assert_debug_equal<T: Debug>(a: T, b: T) {
|
|
assert_eq!(format!("{a:?}"), format!("{b:?}"),);
|
|
}
|
|
|
|
#[cfg(test)]
|
|
fn config_from_file(path: &str) -> Config {
|
|
parse(path).unwrap()
|
|
}
|
|
|
|
fn parse_redis(cfg: &str) -> RedisConnectionInfo {
|
|
let redis = ConnectionInfo::from_str(cfg).unwrap();
|
|
let addr = match redis.addr().clone() {
|
|
ConnectionAddr::Tcp(host, port) => RedisConnectionAddr::Tcp {
|
|
host,
|
|
port,
|
|
tls: false,
|
|
},
|
|
ConnectionAddr::TcpTls { host, port, .. } => RedisConnectionAddr::Tcp {
|
|
host,
|
|
port,
|
|
tls: true,
|
|
},
|
|
ConnectionAddr::Unix(path) => RedisConnectionAddr::Unix { path },
|
|
_ => RedisConnectionAddr::Tcp {
|
|
host: "127.0.0.1".into(),
|
|
port: 6379,
|
|
tls: false,
|
|
},
|
|
};
|
|
RedisConnectionInfo {
|
|
addr,
|
|
db: redis.redis_settings().db(),
|
|
username: redis.redis_settings().username().map(String::from),
|
|
password: redis.redis_settings().password().map(String::from),
|
|
tls_params: None,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_config_basic() {
|
|
let config = config_from_file("tests/configs/basic.php");
|
|
assert_eq!("https://cloud.example.com", config.nextcloud_url);
|
|
assert_eq!("oc_", config.database_prefix);
|
|
assert_debug_equal(
|
|
&Database::MySql {
|
|
database: "nextcloud".to_string(),
|
|
username: "nextcloud".to_string(),
|
|
password: "secret".to_string(),
|
|
connect: DbConnect::Tcp {
|
|
host: "127.0.0.1".to_string(),
|
|
port: 3306,
|
|
},
|
|
ssl_options: SslOptions::Disabled,
|
|
},
|
|
&config.database,
|
|
);
|
|
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"mysql://nextcloud:secret@127.0.0.1/nextcloud?ssl-mode=disabled"
|
|
);
|
|
|
|
assert_debug_equal(
|
|
RedisConfig::Single(parse_redis("redis://127.0.0.1")),
|
|
config.redis,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_implicit_prefix() {
|
|
let config = config_from_file("tests/configs/implicit_prefix.php");
|
|
assert_eq!("oc_", config.database_prefix);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_empty_redis_password() {
|
|
let config = config_from_file("tests/configs/empty_redis_password.php");
|
|
assert_debug_equal(
|
|
RedisConfig::Single(parse_redis("redis://127.0.0.1")),
|
|
config.redis,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_full_redis() {
|
|
let config = config_from_file("tests/configs/full_redis.php");
|
|
assert_debug_equal(
|
|
RedisConfig::Single(parse_redis("redis://name:moresecret@redis:1234/1")),
|
|
config.redis,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_redis_socket() {
|
|
let config = config_from_file("tests/configs/redis_socket.php");
|
|
assert_debug_equal(
|
|
RedisConfig::Single(parse_redis("redis+unix:///redis")),
|
|
config.redis,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_redis_db_str() {
|
|
let config = config_from_file("tests/configs/redis_db_str.php");
|
|
assert_debug_equal(
|
|
RedisConfig::Single(parse_redis("redis://127.0.0.1/1")),
|
|
config.redis,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_notify_push_redis() {
|
|
let config = config_from_file("tests/configs/notify_push_redis.php");
|
|
assert_debug_equal(
|
|
RedisConfig::Single(parse_redis("redis+unix:///redis1")),
|
|
config.redis,
|
|
);
|
|
assert_debug_equal(
|
|
Some(RedisConfig::Single(parse_redis("redis+unix:///redis2"))),
|
|
config.notify_push_redis,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_redis_tls() {
|
|
let config = config_from_file("tests/configs/redis_tls.php");
|
|
assert_debug_equal(
|
|
RedisConfig::Single(RedisConnectionInfo {
|
|
addr: RedisConnectionAddr::Tcp {
|
|
host: "127.0.0.1".into(),
|
|
port: 6379,
|
|
tls: true,
|
|
},
|
|
db: 0,
|
|
username: None,
|
|
password: None,
|
|
tls_params: Some(RedisTlsParams {
|
|
local_cert: Some("/certs/redis.crt".into()),
|
|
local_pk: Some("/certs/redis.key".into()),
|
|
ca_file: Some("/certs/ca.crt".into()),
|
|
insecure: false,
|
|
accept_invalid_hostname: false,
|
|
}),
|
|
}),
|
|
config.redis,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_redis_cluster_tls() {
|
|
let config = config_from_file("tests/configs/redis_cluster_tls.php");
|
|
assert_debug_equal(
|
|
RedisConfig::Cluster(RedisClusterConnectionInfo {
|
|
addr: vec![
|
|
RedisConnectionAddr::Tcp {
|
|
host: "db1".into(),
|
|
port: 6380,
|
|
tls: true,
|
|
},
|
|
RedisConnectionAddr::Tcp {
|
|
host: "db1".into(),
|
|
port: 6381,
|
|
tls: true,
|
|
},
|
|
],
|
|
db: 0,
|
|
username: None,
|
|
password: Some("xxx".into()),
|
|
tls_params: Some(RedisTlsParams {
|
|
local_cert: Some("/certs/redis.crt".into()),
|
|
local_pk: Some("/certs/redis.key".into()),
|
|
ca_file: Some("/certs/ca.crt".into()),
|
|
insecure: false,
|
|
accept_invalid_hostname: false,
|
|
}),
|
|
}),
|
|
config.redis,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_comment_whitespace() {
|
|
let config = config_from_file("tests/configs/comment_whitespace.php");
|
|
assert_eq!("https://cloud.example.com", config.nextcloud_url);
|
|
assert_eq!("oc_", config.database_prefix);
|
|
assert_debug_equal(
|
|
&Database::MySql {
|
|
database: "nextcloud".to_string(),
|
|
username: "nextcloud".to_string(),
|
|
password: "secret".to_string(),
|
|
connect: DbConnect::Tcp {
|
|
host: "127.0.0.1".to_string(),
|
|
port: 3306,
|
|
},
|
|
ssl_options: SslOptions::Disabled,
|
|
},
|
|
&config.database,
|
|
);
|
|
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"mysql://nextcloud:secret@127.0.0.1/nextcloud?ssl-mode=disabled"
|
|
);
|
|
|
|
assert_debug_equal(
|
|
RedisConfig::Single(parse_redis("redis://127.0.0.1")),
|
|
config.redis,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_port_in_host() {
|
|
let config = config_from_file("tests/configs/port_in_host.php");
|
|
assert_debug_equal(
|
|
&Database::MySql {
|
|
database: "nextcloud".to_string(),
|
|
username: "nextcloud".to_string(),
|
|
password: "secret".to_string(),
|
|
connect: DbConnect::Tcp {
|
|
host: "127.0.0.1".to_string(),
|
|
port: 1234,
|
|
},
|
|
ssl_options: SslOptions::Disabled,
|
|
},
|
|
&config.database,
|
|
);
|
|
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"mysql://nextcloud:secret@127.0.0.1:1234/nextcloud?ssl-mode=disabled"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_postgres_socket() {
|
|
let config = config_from_file("tests/configs/postgres_socket.php");
|
|
assert_debug_equal(
|
|
&Database::Postgres {
|
|
database: "nextcloud".to_string(),
|
|
username: "redacted".to_string(),
|
|
password: "redacted".to_string(),
|
|
connect: DbConnect::Socket("/var/run/postgresql".into()),
|
|
options: IndexMap::default(),
|
|
},
|
|
&config.database,
|
|
);
|
|
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"postgresql://redacted:redacted@localhost/nextcloud?host=/var/run/postgresql"
|
|
);
|
|
|
|
assert_debug_equal(
|
|
PgConnectOptions::new()
|
|
.socket("/var/run/postgresql")
|
|
.host("localhost")
|
|
.username("redacted")
|
|
.password("redacted")
|
|
.database("nextcloud"),
|
|
PgConnectOptions::from_str(&config.database.url()).unwrap(),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_postgres_socket_empty_hostname() {
|
|
let config = config_from_file("tests/configs/postgres_socket_no_host.php");
|
|
assert_debug_equal(
|
|
&Database::Postgres {
|
|
database: "nextcloud".to_string(),
|
|
username: "nextcloud".to_string(),
|
|
password: "redacted".to_string(),
|
|
connect: DbConnect::Socket("/run/postgresql".into()),
|
|
options: IndexMap::default(),
|
|
},
|
|
&config.database,
|
|
);
|
|
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"postgresql://nextcloud:redacted@localhost/nextcloud?host=/run/postgresql"
|
|
);
|
|
|
|
assert_debug_equal(
|
|
PgConnectOptions::new()
|
|
.socket("/run/postgresql")
|
|
.host("localhost")
|
|
.username("nextcloud")
|
|
.password("redacted")
|
|
.database("nextcloud"),
|
|
PgConnectOptions::from_str(&config.database.url()).unwrap(),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_postgres_socket_no_pass() {
|
|
let config = config_from_file("tests/configs/postgres_socket_no_pass.php");
|
|
assert_debug_equal(
|
|
&Database::Postgres {
|
|
database: "nextcloud".to_string(),
|
|
username: "redacted".to_string(),
|
|
password: "".to_string(),
|
|
connect: DbConnect::Socket("/var/run/postgresql".into()),
|
|
options: IndexMap::default(),
|
|
},
|
|
&config.database,
|
|
);
|
|
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"postgresql://redacted:@localhost/nextcloud?host=/var/run/postgresql"
|
|
);
|
|
assert_debug_equal(
|
|
PgConnectOptions::new()
|
|
.socket("/var/run/postgresql")
|
|
.host("localhost")
|
|
.username("redacted")
|
|
.database("nextcloud"),
|
|
PgConnectOptions::from_str(&config.database.url()).unwrap(),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_postgres_socket_folder() {
|
|
let config = config_from_file("tests/configs/postgres_socket_folder.php");
|
|
assert_debug_equal(
|
|
&Database::Postgres {
|
|
database: "nextcloud".to_string(),
|
|
username: "redacted".to_string(),
|
|
password: "redacted".to_string(),
|
|
connect: DbConnect::Socket("/var/run/postgresql".into()),
|
|
options: IndexMap::default(),
|
|
},
|
|
&config.database,
|
|
);
|
|
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"postgresql://redacted:redacted@localhost/nextcloud?host=/var/run/postgresql"
|
|
);
|
|
|
|
assert_debug_equal(
|
|
PgConnectOptions::new()
|
|
.socket("/var/run/postgresql")
|
|
.host("localhost")
|
|
.username("redacted")
|
|
.password("redacted")
|
|
.database("nextcloud"),
|
|
PgConnectOptions::from_str(&config.database.url()).unwrap(),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_redis_cluster() {
|
|
let config = config_from_file("tests/configs/redis.cluster.php");
|
|
let mut addresses = config.redis.addr().cloned().collect::<Vec<_>>();
|
|
addresses.sort();
|
|
assert_debug_equal(
|
|
vec![
|
|
parse_redis("redis://:xxx@db1:6380").addr,
|
|
parse_redis("redis://:xxx@db1:6381").addr,
|
|
parse_redis("redis://:xxx@db1:6382").addr,
|
|
parse_redis("redis://:xxx@db2:6380").addr,
|
|
parse_redis("redis://:xxx@db2:6381").addr,
|
|
parse_redis("redis://:xxx@db2:6382").addr,
|
|
],
|
|
addresses,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_redis_cluster_single() {
|
|
let config = config_from_file("tests/configs/redis_cluster_single.php");
|
|
assert!(matches!(config.redis, RedisConfig::Cluster(_)));
|
|
let addresses = config.redis.addr().cloned().collect::<Vec<_>>();
|
|
assert_debug_equal(vec![parse_redis("redis://:xxx@db1:6380").addr], addresses);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_config_multiple() {
|
|
let config = parse_glob("tests/configs/multiple/config.php").unwrap();
|
|
assert_eq!("https://cloud.example.com", config.nextcloud_url);
|
|
assert_eq!("oc_", config.database_prefix);
|
|
assert_debug_equal(
|
|
&Database::MySql {
|
|
database: "nextcloud".to_string(),
|
|
username: "nextcloud".to_string(),
|
|
password: "secret".to_string(),
|
|
connect: DbConnect::Tcp {
|
|
host: "127.0.0.1".to_string(),
|
|
port: 3306,
|
|
},
|
|
ssl_options: SslOptions::Disabled,
|
|
},
|
|
&config.database,
|
|
);
|
|
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"mysql://nextcloud:secret@127.0.0.1/nextcloud?ssl-mode=disabled"
|
|
);
|
|
|
|
assert_debug_equal(
|
|
RedisConfig::Single(parse_redis("redis://127.0.0.1")),
|
|
config.redis,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_config_multiple_no_glob() {
|
|
let config = config_from_file("tests/configs/multiple/config.php");
|
|
assert_eq!("https://cloud.example.com", config.nextcloud_url);
|
|
assert_eq!("oc_", config.database_prefix);
|
|
assert_debug_equal(
|
|
&Database::Sqlite {
|
|
database: "/nc/nextcloud.db".into(),
|
|
},
|
|
&config.database,
|
|
);
|
|
assert_debug_equal(
|
|
AnyConnectOptions::from_str("sqlite:///nc/nextcloud.db").unwrap(),
|
|
AnyConnectOptions::from_str(&config.database.url()).unwrap(),
|
|
);
|
|
assert_debug_equal(
|
|
RedisConfig::Single(parse_redis("redis://127.0.0.1")),
|
|
config.redis,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_config_mysql_fqdn() {
|
|
let config = config_from_file("tests/configs/mysql_fqdn.php");
|
|
assert_debug_equal(
|
|
&Database::MySql {
|
|
database: "nextcloud".to_string(),
|
|
username: "nextcloud".to_string(),
|
|
password: "secret".to_string(),
|
|
connect: DbConnect::Tcp {
|
|
host: "db.example.com".to_string(),
|
|
port: 3306,
|
|
},
|
|
ssl_options: SslOptions::Default,
|
|
},
|
|
&config.database,
|
|
);
|
|
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"mysql://nextcloud:secret@db.example.com/nextcloud"
|
|
);
|
|
|
|
assert_debug_equal(
|
|
MySqlConnectOptions::new()
|
|
.username("nextcloud")
|
|
.password("secret")
|
|
.database("nextcloud")
|
|
.host("db.example.com")
|
|
.ssl_mode(MySqlSslMode::Preferred),
|
|
MySqlConnectOptions::from_str(&config.database.url()).unwrap(),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_config_mysql_ip_no_verify() {
|
|
let config = config_from_file("tests/configs/mysql_ip_no_verify.php");
|
|
assert_debug_equal(
|
|
&Database::MySql {
|
|
database: "nextcloud".to_string(),
|
|
username: "nextcloud".to_string(),
|
|
password: "secret".to_string(),
|
|
connect: DbConnect::Tcp {
|
|
host: "1.2.3.4".to_string(),
|
|
port: 3306,
|
|
},
|
|
ssl_options: SslOptions::Default,
|
|
},
|
|
&config.database,
|
|
);
|
|
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"mysql://nextcloud:secret@1.2.3.4/nextcloud"
|
|
);
|
|
|
|
assert_debug_equal(
|
|
MySqlConnectOptions::new()
|
|
.username("nextcloud")
|
|
.password("secret")
|
|
.database("nextcloud")
|
|
.host("1.2.3.4")
|
|
.ssl_mode(MySqlSslMode::Preferred),
|
|
MySqlConnectOptions::from_str(&config.database.url()).unwrap(),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_config_mysql_ssl_ca() {
|
|
let config = config_from_file("tests/configs/mysql_ssl_ca.php");
|
|
assert_debug_equal(
|
|
&Database::MySql {
|
|
database: "nextcloud".to_string(),
|
|
username: "nextcloud".to_string(),
|
|
password: "secret".to_string(),
|
|
connect: DbConnect::Tcp {
|
|
host: "db.example.com".to_string(),
|
|
port: 3306,
|
|
},
|
|
ssl_options: SslOptions::Enabled {
|
|
key: "/ssl-key.pem".into(),
|
|
cert: "/ssl-cert.pem".into(),
|
|
ca: "/ca-cert.pem".into(),
|
|
verify: true,
|
|
},
|
|
},
|
|
&config.database,
|
|
);
|
|
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"mysql://nextcloud:secret@db.example.com/nextcloud?ssl-mode=verify_identity&ssl-ca=/ca-cert.pem"
|
|
);
|
|
|
|
assert_debug_equal(
|
|
MySqlConnectOptions::new()
|
|
.username("nextcloud")
|
|
.password("secret")
|
|
.database("nextcloud")
|
|
.host("db.example.com")
|
|
.ssl_mode(MySqlSslMode::VerifyIdentity)
|
|
.ssl_ca("/ca-cert.pem"),
|
|
MySqlConnectOptions::from_str(&config.database.url()).unwrap(),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_config_mysql_ssl_ca_no_verify() {
|
|
let config = config_from_file("tests/configs/mysql_ssl_ca_no_verify.php");
|
|
assert_debug_equal(
|
|
&Database::MySql {
|
|
database: "nextcloud".to_string(),
|
|
username: "nextcloud".to_string(),
|
|
password: "secret".to_string(),
|
|
connect: DbConnect::Tcp {
|
|
host: "db.example.com".to_string(),
|
|
port: 3306,
|
|
},
|
|
ssl_options: SslOptions::Enabled {
|
|
key: "/ssl-key.pem".into(),
|
|
cert: "/ssl-cert.pem".into(),
|
|
ca: "/ca-cert.pem".into(),
|
|
verify: false,
|
|
},
|
|
},
|
|
&config.database,
|
|
);
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"mysql://nextcloud:secret@db.example.com/nextcloud?ssl-mode=verify_ca&ssl-ca=/ca-cert.pem"
|
|
);
|
|
|
|
assert_debug_equal(
|
|
MySqlConnectOptions::new()
|
|
.username("nextcloud")
|
|
.password("secret")
|
|
.database("nextcloud")
|
|
.host("db.example.com")
|
|
.ssl_mode(MySqlSslMode::VerifyCa)
|
|
.ssl_ca("/ca-cert.pem"),
|
|
MySqlConnectOptions::from_str(&config.database.url()).unwrap(),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_postgres_ip() {
|
|
let config = config_from_file("tests/configs/postgres_ip.php");
|
|
assert_debug_equal(
|
|
&Database::Postgres {
|
|
database: "nextcloud".to_string(),
|
|
username: "redacted".to_string(),
|
|
password: "redacted".to_string(),
|
|
connect: DbConnect::Tcp {
|
|
host: "1.2.3.4".to_string(),
|
|
port: 5432,
|
|
},
|
|
options: indexmap! {
|
|
"sslmode".into() => "disable".into()
|
|
},
|
|
},
|
|
&config.database,
|
|
);
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"postgresql://redacted:redacted@1.2.3.4/nextcloud?sslmode=disable"
|
|
);
|
|
|
|
assert_debug_equal(
|
|
PgConnectOptions::new()
|
|
.host("1.2.3.4")
|
|
.username("redacted")
|
|
.password("redacted")
|
|
.database("nextcloud")
|
|
.port(5432)
|
|
.ssl_mode(sqlx::postgres::PgSslMode::Disable),
|
|
PgConnectOptions::from_str(&config.database.url()).unwrap(),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_postgres_fqdn() {
|
|
let config = config_from_file("tests/configs/postgres_fqdn.php");
|
|
assert_debug_equal(
|
|
&Database::Postgres {
|
|
database: "nextcloud".to_string(),
|
|
username: "redacted".to_string(),
|
|
password: "redacted".to_string(),
|
|
connect: DbConnect::Tcp {
|
|
host: "pg.example.com".to_string(),
|
|
port: 5432,
|
|
},
|
|
options: IndexMap::default(),
|
|
},
|
|
&config.database,
|
|
);
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"postgresql://redacted:redacted@pg.example.com/nextcloud"
|
|
);
|
|
|
|
assert_debug_equal(
|
|
PgConnectOptions::new()
|
|
.host("pg.example.com")
|
|
.username("redacted")
|
|
.password("redacted")
|
|
.port(5432)
|
|
.database("nextcloud"),
|
|
PgConnectOptions::from_str(&config.database.url()).unwrap(),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_config_sqlite_default_db() {
|
|
let config = config_from_file("tests/configs/sqlite_default_db.php");
|
|
assert_debug_equal(
|
|
&Database::Sqlite {
|
|
database: "/nc/data/owncloud.db".into(),
|
|
},
|
|
&config.database,
|
|
);
|
|
|
|
assert_debug_equal(
|
|
SqliteConnectOptions::new().filename("/nc/data/owncloud.db"),
|
|
SqliteConnectOptions::from_str(&config.database.url()).unwrap(),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_config_nested_array() {
|
|
let config = config_from_file("tests/configs/nested_array.php");
|
|
assert_eq!("https://cloud.example.com", config.nextcloud_url);
|
|
assert_eq!("oc_", config.database_prefix);
|
|
assert_debug_equal(
|
|
&Database::MySql {
|
|
database: "nextcloud".to_string(),
|
|
username: "nextcloud".to_string(),
|
|
password: "secret".to_string(),
|
|
connect: DbConnect::Tcp {
|
|
host: "127.0.0.1".to_string(),
|
|
port: 3306,
|
|
},
|
|
ssl_options: SslOptions::Disabled,
|
|
},
|
|
&config.database,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_postgres_escaped_credentials() {
|
|
let config = config_from_file("tests/configs/postgres_escape.php");
|
|
assert_debug_equal(
|
|
&Database::Postgres {
|
|
database: "nextcloud".to_string(),
|
|
username: "reda:cted".to_string(),
|
|
password: "reda@cted".to_string(),
|
|
connect: DbConnect::Tcp {
|
|
host: "1.2.3.4".to_string(),
|
|
port: 5432,
|
|
},
|
|
options: indexmap! {
|
|
"sslmode".into() => "disable".into()
|
|
},
|
|
},
|
|
&config.database,
|
|
);
|
|
assert_eq!(
|
|
config.database.url(),
|
|
"postgresql://reda%3Acted:reda%40cted@1.2.3.4/nextcloud?sslmode=disable"
|
|
);
|
|
|
|
assert_debug_equal(
|
|
PgConnectOptions::new()
|
|
.host("1.2.3.4")
|
|
.username("reda:cted")
|
|
.password("reda@cted")
|
|
.port(5432)
|
|
.database("nextcloud")
|
|
.ssl_mode(sqlx::postgres::PgSslMode::Disable),
|
|
PgConnectOptions::from_str(&config.database.url()).unwrap(),
|
|
);
|
|
}
|