use std::fmt;
use std::str::FromStr;
use std::time::Duration;
use crate::common::errors::ConfigError;
pub const DEMO_HOST: &str = "demo.ctraderapi.com";
pub const LIVE_HOST: &str = "live.ctraderapi.com";
pub const DEFAULT_PORT: u16 = 5035;
pub const DEFAULT_TOKEN_URL: &str = "https://connect.spotware.com/apps/token";
pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);
pub const DEFAULT_RETRIES: u32 = 3;
pub const DEFAULT_BACKOFF: Duration = Duration::from_secs(1);
pub const DEFAULT_RECONNECT_DELAY: Duration = Duration::from_secs(5);
pub const ENV_CLIENT_ID: &str = "BROKER_CLIENT_ID";
pub const ENV_CLIENT_SECRET: &str = "BROKER_CLIENT_SECRET";
pub const ENV_ACCESS_TOKEN: &str = "BROKER_ACCESS_TOKEN";
pub const ENV_REFRESH_TOKEN: &str = "BROKER_REFRESH_TOKEN";
pub const ENV_DEMO_HOST: &str = "BROKER_DEMO_HOST";
pub const ENV_TOKEN_URL: &str = "BROKER_TOKEN_URL";
pub const ENV_ENVIRONMENT: &str = "BROKER_ENVIRONMENT";
const CLIENT_ID: &str = "client_id";
const CLIENT_SECRET: &str = "client_secret";
const ACCESS_TOKEN: &str = "access_token";
const REFRESH_TOKEN: &str = "refresh_token";
const FIX_PASSWORD: &str = "fix_password";
const TIMEOUT: &str = "timeout";
const BACKOFF: &str = "backoff";
const RECONNECT_DELAY: &str = "reconnect_delay";
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum Environment {
#[default]
Demo,
Live,
}
impl Environment {
#[must_use]
pub const fn host(self) -> &'static str {
match self {
Self::Demo => DEMO_HOST,
Self::Live => LIVE_HOST,
}
}
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Demo => "demo",
Self::Live => "live",
}
}
}
impl fmt::Display for Environment {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
impl FromStr for Environment {
type Err = ConfigError;
fn from_str(text: &str) -> Result<Self, Self::Err> {
match text {
"demo" => Ok(Self::Demo),
"live" => Ok(Self::Live),
other => Err(ConfigError::InvalidEnvironment(other.to_owned())),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ClientId(String);
impl ClientId {
pub fn new(value: impl Into<String>) -> Result<Self, ConfigError> {
filled(value.into(), CLIENT_ID).map(Self)
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
macro_rules! secret {
($(#[$doc:meta])* $name:ident, $option:expr) => {
$(#[$doc])*
#[derive(Clone, PartialEq, Eq)]
pub struct $name(String);
impl $name {
pub fn new(value: impl Into<String>) -> Result<Self, ConfigError> {
filled(value.into(), $option).map(Self)
}
#[must_use]
pub fn expose(&self) -> &str {
&self.0
}
}
impl fmt::Debug for $name {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(concat!(stringify!($name), "(***)"))
}
}
};
}
secret!(
ClientSecret,
CLIENT_SECRET
);
secret!(
AccessToken,
ACCESS_TOKEN
);
secret!(
RefreshToken,
REFRESH_TOKEN
);
secret!(
FixPassword,
FIX_PASSWORD
);
fn filled(value: String, option: &'static str) -> Result<String, ConfigError> {
if value.trim().is_empty() {
Err(ConfigError::Missing(option))
} else {
Ok(value)
}
}
fn host_name(value: String) -> Result<String, ConfigError> {
let bare = !value.is_empty()
&& value
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '.' || c == '-');
if bare {
Ok(value)
} else {
Err(ConfigError::InvalidHost(value))
}
}
fn https_url(value: String) -> Result<String, ConfigError> {
let valid = value.strip_prefix("https://").is_some_and(|rest| {
!rest.is_empty() && !rest.starts_with('/') && !rest.contains(char::is_whitespace)
});
if valid {
Ok(value)
} else {
Err(ConfigError::InvalidTokenUrl(value))
}
}
fn positive(value: Duration, option: &'static str) -> Result<Duration, ConfigError> {
if value.is_zero() {
Err(ConfigError::ZeroDuration(option))
} else {
Ok(value)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ConfigurationOpenApi {
environment: Environment,
host: String,
port: u16,
client_id: ClientId,
client_secret: ClientSecret,
access_token: AccessToken,
refresh_token: Option<RefreshToken>,
token_url: String,
timeout: Duration,
retries: u32,
backoff: Duration,
reconnect_delay: Duration,
}
impl ConfigurationOpenApi {
pub fn builder() -> ConfigurationOpenApiBuilder {
Self::demo()
}
pub fn demo() -> ConfigurationOpenApiBuilder {
ConfigurationOpenApiBuilder::new(Environment::Demo)
}
pub fn live() -> ConfigurationOpenApiBuilder {
ConfigurationOpenApiBuilder::new(Environment::Live)
}
pub fn from_env() -> Result<Self, ConfigError> {
Self::from_lookup(|key| std::env::var(key).ok())
}
pub fn from_lookup(lookup: impl Fn(&str) -> Option<String>) -> Result<Self, ConfigError> {
let optional = |key: &str| lookup(key).filter(|value| !value.trim().is_empty());
let required = |key: &'static str| optional(key).ok_or(ConfigError::Missing(key));
let environment = match optional(ENV_ENVIRONMENT) {
Some(name) => name.parse()?,
None => Environment::Demo,
};
let mut builder = ConfigurationOpenApiBuilder::new(environment)
.client_id(required(ENV_CLIENT_ID)?)
.client_secret(required(ENV_CLIENT_SECRET)?)
.access_token(required(ENV_ACCESS_TOKEN)?);
if let Some(token) = optional(ENV_REFRESH_TOKEN) {
builder = builder.refresh_token(token);
}
if let Some(url) = optional(ENV_TOKEN_URL) {
builder = builder.token_url(url);
}
if environment == Environment::Demo {
if let Some(host) = optional(ENV_DEMO_HOST) {
builder = builder.host(host);
}
}
builder.build()
}
#[must_use]
pub const fn environment(&self) -> Environment {
self.environment
}
#[must_use]
pub fn host(&self) -> &str {
&self.host
}
#[must_use]
pub const fn port(&self) -> u16 {
self.port
}
#[must_use]
pub const fn client_id(&self) -> &ClientId {
&self.client_id
}
#[must_use]
pub const fn client_secret(&self) -> &ClientSecret {
&self.client_secret
}
#[must_use]
pub const fn access_token(&self) -> &AccessToken {
&self.access_token
}
#[must_use]
pub const fn refresh_token(&self) -> Option<&RefreshToken> {
self.refresh_token.as_ref()
}
#[must_use]
pub fn token_url(&self) -> &str {
&self.token_url
}
#[must_use]
pub const fn timeout(&self) -> Duration {
self.timeout
}
#[must_use]
pub const fn retries(&self) -> u32 {
self.retries
}
#[must_use]
pub const fn backoff(&self) -> Duration {
self.backoff
}
#[must_use]
pub const fn reconnect_delay(&self) -> Duration {
self.reconnect_delay
}
}
#[derive(Debug, Clone)]
#[must_use]
pub struct ConfigurationOpenApiBuilder {
environment: Environment,
host: Option<String>,
port: u16,
client_id: Option<String>,
client_secret: Option<String>,
access_token: Option<String>,
refresh_token: Option<String>,
token_url: String,
timeout: Duration,
retries: u32,
backoff: Duration,
reconnect_delay: Duration,
}
impl ConfigurationOpenApiBuilder {
fn new(environment: Environment) -> Self {
Self {
environment,
host: None,
port: DEFAULT_PORT,
client_id: None,
client_secret: None,
access_token: None,
refresh_token: None,
token_url: DEFAULT_TOKEN_URL.to_owned(),
timeout: DEFAULT_TIMEOUT,
retries: DEFAULT_RETRIES,
backoff: DEFAULT_BACKOFF,
reconnect_delay: DEFAULT_RECONNECT_DELAY,
}
}
pub fn host(mut self, host: impl Into<String>) -> Self {
self.host = Some(host.into());
self
}
pub fn port(mut self, port: u16) -> Self {
self.port = port;
self
}
pub fn client_id(mut self, client_id: impl Into<String>) -> Self {
self.client_id = Some(client_id.into());
self
}
pub fn client_secret(mut self, client_secret: impl Into<String>) -> Self {
self.client_secret = Some(client_secret.into());
self
}
pub fn access_token(mut self, access_token: impl Into<String>) -> Self {
self.access_token = Some(access_token.into());
self
}
pub fn refresh_token(mut self, refresh_token: impl Into<String>) -> Self {
self.refresh_token = Some(refresh_token.into());
self
}
pub fn token_url(mut self, token_url: impl Into<String>) -> Self {
self.token_url = token_url.into();
self
}
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = timeout;
self
}
pub fn retries(mut self, retries: u32) -> Self {
self.retries = retries;
self
}
pub fn backoff(mut self, backoff: Duration) -> Self {
self.backoff = backoff;
self
}
pub fn reconnect_delay(mut self, reconnect_delay: Duration) -> Self {
self.reconnect_delay = reconnect_delay;
self
}
pub fn build(self) -> Result<ConfigurationOpenApi, ConfigError> {
let host = self
.host
.unwrap_or_else(|| self.environment.host().to_owned());
Ok(ConfigurationOpenApi {
environment: self.environment,
host: host_name(host)?,
port: if self.port == 0 {
return Err(ConfigError::InvalidPort);
} else {
self.port
},
client_id: ClientId::new(self.client_id.unwrap_or_default())?,
client_secret: ClientSecret::new(self.client_secret.unwrap_or_default())?,
access_token: AccessToken::new(self.access_token.unwrap_or_default())?,
refresh_token: self.refresh_token.map(RefreshToken::new).transpose()?,
token_url: https_url(self.token_url)?,
timeout: positive(self.timeout, TIMEOUT)?,
retries: self.retries,
backoff: positive(self.backoff, BACKOFF)?,
reconnect_delay: positive(self.reconnect_delay, RECONNECT_DELAY)?,
})
}
}
pub const ENV_FIX_HOST: &str = "BROKER_FIX_HOST";
pub const ENV_FIX_QUOTE_PORT: &str = "BROKER_FIX_QUOTE_PORT";
pub const ENV_FIX_TRADE_PORT: &str = "BROKER_FIX_TRADE_PORT";
pub const ENV_FIX_SENDER_COMP_ID: &str = "BROKER_FIX_SENDER_COMP_ID";
pub const ENV_FIX_TARGET_COMP_ID: &str = "BROKER_FIX_TARGET_COMP_ID";
pub const ENV_FIX_USERNAME: &str = "BROKER_FIX_USERNAME";
pub const ENV_FIX_PASSWORD: &str = "BROKER_FIX_PASSWORD";
pub const DEFAULT_FIX_QUOTE_PORT: u16 = 5211;
pub const DEFAULT_FIX_TRADE_PORT: u16 = 5212;
pub const DEFAULT_FIX_QUOTE_PLAIN_PORT: u16 = 5201;
pub const DEFAULT_FIX_TRADE_PLAIN_PORT: u16 = 5202;
pub const DEFAULT_FIX_TARGET_COMP_ID: &str = "CSERVER";
pub const DEFAULT_FIX_HEARTBEAT: Duration = Duration::from_secs(30);
pub const MAX_FIX_HEARTBEAT: Duration = Duration::from_secs(3_600);
pub const MAX_FIX_RECONNECT_DELAY: Duration = Duration::from_secs(3_600);
const FIX_HOST: &str = "host";
const FIX_SENDER_COMP_ID: &str = "sender_comp_id";
const FIX_TARGET_COMP_ID: &str = "target_comp_id";
const FIX_USERNAME: &str = "username";
const HEARTBEAT: &str = "heartbeat";
fn port_number(text: &str) -> Result<u16, ConfigError> {
match text.trim().parse::<u16>() {
Ok(port) if port > 0 => Ok(port),
_ => Err(ConfigError::InvalidPort),
}
}
fn nonzero_port(port: u16) -> Result<u16, ConfigError> {
if port == 0 {
Err(ConfigError::InvalidPort)
} else {
Ok(port)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ConfigurationFix {
host: String,
quote_port: u16,
trade_port: u16,
encrypted: bool,
sender_comp_id: String,
target_comp_id: String,
username: String,
password: FixPassword,
heartbeat: Duration,
timeout: Duration,
reconnect_delay: Duration,
}
impl ConfigurationFix {
pub fn builder() -> ConfigurationFixBuilder {
ConfigurationFixBuilder::new()
}
pub fn from_env() -> Result<Self, ConfigError> {
Self::from_lookup(|key| std::env::var(key).ok())
}
pub fn from_lookup(lookup: impl Fn(&str) -> Option<String>) -> Result<Self, ConfigError> {
let optional = |key: &str| lookup(key).filter(|value| !value.trim().is_empty());
let required = |key: &'static str| optional(key).ok_or(ConfigError::Missing(key));
let mut builder = Self::builder()
.host(required(ENV_FIX_HOST)?)
.sender_comp_id(required(ENV_FIX_SENDER_COMP_ID)?)
.username(required(ENV_FIX_USERNAME)?)
.password(required(ENV_FIX_PASSWORD)?);
if let Some(port) = optional(ENV_FIX_QUOTE_PORT) {
builder = builder.quote_port(port_number(&port)?);
}
if let Some(port) = optional(ENV_FIX_TRADE_PORT) {
builder = builder.trade_port(port_number(&port)?);
}
if let Some(target) = optional(ENV_FIX_TARGET_COMP_ID) {
builder = builder.target_comp_id(target);
}
builder.build()
}
#[must_use]
pub fn host(&self) -> &str {
&self.host
}
#[must_use]
pub const fn quote_port(&self) -> u16 {
self.quote_port
}
#[must_use]
pub const fn trade_port(&self) -> u16 {
self.trade_port
}
#[must_use]
pub const fn encrypted(&self) -> bool {
self.encrypted
}
#[must_use]
pub fn sender_comp_id(&self) -> &str {
&self.sender_comp_id
}
#[must_use]
pub fn target_comp_id(&self) -> &str {
&self.target_comp_id
}
#[must_use]
pub fn username(&self) -> &str {
&self.username
}
#[must_use]
pub const fn password(&self) -> &FixPassword {
&self.password
}
#[must_use]
pub const fn heartbeat(&self) -> Duration {
self.heartbeat
}
#[must_use]
pub const fn timeout(&self) -> Duration {
self.timeout
}
#[must_use]
pub const fn reconnect_delay(&self) -> Duration {
self.reconnect_delay
}
}
#[derive(Debug, Clone)]
#[must_use]
pub struct ConfigurationFixBuilder {
host: Option<String>,
quote_port: Option<u16>,
trade_port: Option<u16>,
encrypted: bool,
sender_comp_id: Option<String>,
target_comp_id: String,
username: Option<String>,
password: Option<FixPassword>,
heartbeat: Duration,
timeout: Duration,
reconnect_delay: Duration,
}
impl ConfigurationFixBuilder {
fn new() -> Self {
Self {
host: None,
quote_port: None,
trade_port: None,
encrypted: true,
sender_comp_id: None,
target_comp_id: DEFAULT_FIX_TARGET_COMP_ID.to_owned(),
username: None,
password: None,
heartbeat: DEFAULT_FIX_HEARTBEAT,
timeout: DEFAULT_TIMEOUT,
reconnect_delay: DEFAULT_RECONNECT_DELAY,
}
}
pub fn host(mut self, host: impl Into<String>) -> Self {
self.host = Some(host.into());
self
}
pub const fn quote_port(mut self, port: u16) -> Self {
self.quote_port = Some(port);
self
}
pub const fn trade_port(mut self, port: u16) -> Self {
self.trade_port = Some(port);
self
}
pub const fn unencrypted(mut self) -> Self {
self.encrypted = false;
self
}
pub fn sender_comp_id(mut self, sender_comp_id: impl Into<String>) -> Self {
self.sender_comp_id = Some(sender_comp_id.into());
self
}
pub fn target_comp_id(mut self, target_comp_id: impl Into<String>) -> Self {
self.target_comp_id = target_comp_id.into();
self
}
pub fn username(mut self, username: impl Into<String>) -> Self {
self.username = Some(username.into());
self
}
pub fn password(mut self, password: impl Into<String>) -> Self {
self.password = FixPassword::new(password).ok();
self
}
pub const fn heartbeat(mut self, heartbeat: Duration) -> Self {
self.heartbeat = heartbeat;
self
}
pub const fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = timeout;
self
}
pub const fn reconnect_delay(mut self, reconnect_delay: Duration) -> Self {
self.reconnect_delay = reconnect_delay;
self
}
pub fn build(self) -> Result<ConfigurationFix, ConfigError> {
let (quote, trade) = if self.encrypted {
(DEFAULT_FIX_QUOTE_PORT, DEFAULT_FIX_TRADE_PORT)
} else {
(DEFAULT_FIX_QUOTE_PLAIN_PORT, DEFAULT_FIX_TRADE_PLAIN_PORT)
};
if self.heartbeat.as_secs() == 0 {
return Err(ConfigError::ZeroDuration(HEARTBEAT));
}
if self.heartbeat > MAX_FIX_HEARTBEAT {
return Err(ConfigError::TooLong {
option: HEARTBEAT,
limit: MAX_FIX_HEARTBEAT,
});
}
Ok(ConfigurationFix {
host: host_name(filled(self.host.unwrap_or_default(), FIX_HOST)?)?,
quote_port: nonzero_port(self.quote_port.unwrap_or(quote))?,
trade_port: nonzero_port(self.trade_port.unwrap_or(trade))?,
encrypted: self.encrypted,
sender_comp_id: filled(self.sender_comp_id.unwrap_or_default(), FIX_SENDER_COMP_ID)?,
target_comp_id: filled(self.target_comp_id, FIX_TARGET_COMP_ID)?,
username: filled(self.username.unwrap_or_default(), FIX_USERNAME)?,
password: self.password.ok_or(ConfigError::Missing(FIX_PASSWORD))?,
heartbeat: Duration::from_secs(self.heartbeat.as_secs()),
timeout: positive(self.timeout, TIMEOUT)?,
reconnect_delay: positive(self.reconnect_delay, RECONNECT_DELAY)?
.min(MAX_FIX_RECONNECT_DELAY),
})
}
}
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use std::time::Duration;
use super::{
AccessToken, ClientId, ClientSecret, ConfigurationOpenApi, ConfigurationOpenApiBuilder,
DEFAULT_BACKOFF, DEFAULT_PORT, DEFAULT_RECONNECT_DELAY, DEFAULT_RETRIES, DEFAULT_TIMEOUT,
DEFAULT_TOKEN_URL, DEMO_HOST, ENV_ACCESS_TOKEN, ENV_CLIENT_ID, ENV_CLIENT_SECRET,
ENV_DEMO_HOST, ENV_ENVIRONMENT, ENV_REFRESH_TOKEN, ENV_TOKEN_URL, Environment, LIVE_HOST,
RefreshToken,
};
use super::{
ConfigurationFix, ConfigurationFixBuilder, DEFAULT_FIX_HEARTBEAT,
DEFAULT_FIX_QUOTE_PLAIN_PORT, DEFAULT_FIX_QUOTE_PORT, DEFAULT_FIX_TARGET_COMP_ID,
DEFAULT_FIX_TRADE_PLAIN_PORT, DEFAULT_FIX_TRADE_PORT, ENV_FIX_HOST, ENV_FIX_PASSWORD,
ENV_FIX_QUOTE_PORT, ENV_FIX_SENDER_COMP_ID, ENV_FIX_TARGET_COMP_ID, ENV_FIX_TRADE_PORT,
ENV_FIX_USERNAME, MAX_FIX_HEARTBEAT, MAX_FIX_RECONNECT_DELAY,
};
use crate::common::errors::ConfigError;
fn filled(builder: ConfigurationOpenApiBuilder) -> ConfigurationOpenApiBuilder {
builder
.client_id("id")
.client_secret("secret")
.access_token("access")
}
fn lookup(pairs: &[(&str, &str)]) -> impl Fn(&str) -> Option<String> {
let map: HashMap<String, String> = pairs
.iter()
.map(|(key, value)| ((*key).to_owned(), (*value).to_owned()))
.collect();
move |key| map.get(key).cloned()
}
const REQUIRED: [(&str, &str); 3] = [
(ENV_CLIENT_ID, "id"),
(ENV_CLIENT_SECRET, "secret"),
(ENV_ACCESS_TOKEN, "access"),
];
fn with(extra: &[(&'static str, &'static str)]) -> Vec<(&'static str, &'static str)> {
REQUIRED.iter().chain(extra).copied().collect()
}
#[test]
fn builder_defaults_to_demo() -> Result<(), ConfigError> {
let configuration = filled(ConfigurationOpenApi::builder()).build()?;
assert_eq!(configuration.environment(), Environment::Demo);
assert_eq!(configuration.host(), DEMO_HOST);
assert_eq!(configuration.host(), "demo.ctraderapi.com");
assert_eq!(configuration.port(), DEFAULT_PORT);
assert_eq!(configuration.port(), 5035);
assert_eq!(configuration.client_id().as_str(), "id");
assert_eq!(configuration.client_secret().expose(), "secret");
assert_eq!(configuration.access_token().expose(), "access");
assert_eq!(configuration.refresh_token(), None);
assert_eq!(configuration.token_url(), DEFAULT_TOKEN_URL);
assert_eq!(configuration.timeout(), DEFAULT_TIMEOUT);
assert_eq!(configuration.retries(), DEFAULT_RETRIES);
assert_eq!(configuration.backoff(), DEFAULT_BACKOFF);
assert_eq!(configuration.reconnect_delay(), DEFAULT_RECONNECT_DELAY);
Ok(())
}
#[test]
fn demo_constructor_equals_the_default_builder() -> Result<(), ConfigError> {
let demo = filled(ConfigurationOpenApi::demo()).build()?;
let default = filled(ConfigurationOpenApi::builder()).build()?;
assert_eq!(demo, default);
Ok(())
}
#[test]
fn live_constructor_targets_the_live_host() -> Result<(), ConfigError> {
let configuration = filled(ConfigurationOpenApi::live()).build()?;
assert_eq!(configuration.environment(), Environment::Live);
assert_eq!(configuration.host(), LIVE_HOST);
assert_eq!(configuration.host(), "live.ctraderapi.com");
assert_eq!(configuration.port(), 5035);
Ok(())
}
#[test]
fn overrides_replace_every_default() -> Result<(), ConfigError> {
let configuration = filled(ConfigurationOpenApi::builder())
.host("proxy.example.test")
.port(6000)
.refresh_token("refresh")
.token_url("https://auth.example.test/token")
.timeout(Duration::from_millis(250))
.retries(0)
.backoff(Duration::from_millis(40))
.reconnect_delay(Duration::from_secs(9))
.build()?;
assert_eq!(configuration.host(), "proxy.example.test");
assert_eq!(configuration.port(), 6000);
assert_eq!(
configuration.refresh_token().map(RefreshToken::expose),
Some("refresh")
);
assert_eq!(configuration.token_url(), "https://auth.example.test/token");
assert_eq!(configuration.timeout(), Duration::from_millis(250));
assert_eq!(configuration.retries(), 0);
assert_eq!(configuration.backoff(), Duration::from_millis(40));
assert_eq!(configuration.reconnect_delay(), Duration::from_secs(9));
Ok(())
}
#[test]
fn missing_credentials_are_rejected() {
let no_id = ConfigurationOpenApi::builder()
.client_secret("secret")
.access_token("access")
.build();
assert_eq!(no_id, Err(ConfigError::Missing("client_id")));
let no_secret = ConfigurationOpenApi::builder()
.client_id("id")
.access_token("access")
.build();
assert_eq!(no_secret, Err(ConfigError::Missing("client_secret")));
let no_token = ConfigurationOpenApi::builder()
.client_id("id")
.client_secret("secret")
.build();
assert_eq!(no_token, Err(ConfigError::Missing("access_token")));
}
#[test]
fn blank_credentials_are_rejected() {
let builder = || filled(ConfigurationOpenApi::builder());
assert_eq!(
builder().client_id(" ").build(),
Err(ConfigError::Missing("client_id"))
);
assert_eq!(
builder().client_secret("").build(),
Err(ConfigError::Missing("client_secret"))
);
assert_eq!(
builder().access_token("").build(),
Err(ConfigError::Missing("access_token"))
);
assert_eq!(
builder().refresh_token("").build(),
Err(ConfigError::Missing("refresh_token"))
);
}
#[test]
fn bad_hosts_and_ports_are_rejected() {
let builder = || filled(ConfigurationOpenApi::builder());
for host in ["", "host name", "https://host", "host:5035", "host/path"] {
assert_eq!(
builder().host(host).build(),
Err(ConfigError::InvalidHost(host.to_owned()))
);
}
assert_eq!(builder().port(0).build(), Err(ConfigError::InvalidPort));
}
#[test]
fn bad_token_urls_are_rejected() {
let builder = || filled(ConfigurationOpenApi::builder());
for url in [
"",
"http://auth.example.test/token",
"https://",
"https:///token",
"https://a b",
] {
assert_eq!(
builder().token_url(url).build(),
Err(ConfigError::InvalidTokenUrl(url.to_owned()))
);
}
}
#[test]
fn zero_durations_are_rejected() {
let builder = || filled(ConfigurationOpenApi::builder());
assert_eq!(
builder().timeout(Duration::ZERO).build(),
Err(ConfigError::ZeroDuration("timeout"))
);
assert_eq!(
builder().backoff(Duration::ZERO).build(),
Err(ConfigError::ZeroDuration("backoff"))
);
assert_eq!(
builder().reconnect_delay(Duration::ZERO).build(),
Err(ConfigError::ZeroDuration("reconnect_delay"))
);
}
#[test]
fn secrets_are_redacted_in_debug_output() -> Result<(), ConfigError> {
let configuration = filled(ConfigurationOpenApi::builder())
.client_secret("s3cr3t-value")
.access_token("acc3ss-value")
.refresh_token("r3fr3sh-value")
.build()?;
let printed = format!("{configuration:?}");
assert!(!printed.contains("s3cr3t-value"));
assert!(!printed.contains("acc3ss-value"));
assert!(!printed.contains("r3fr3sh-value"));
assert!(printed.contains("ClientSecret(***)"));
assert!(printed.contains("AccessToken(***)"));
assert!(printed.contains("RefreshToken(***)"));
assert_eq!(
format!("{:?}", ClientSecret::new("x")?),
"ClientSecret(***)"
);
assert_eq!(format!("{:?}", AccessToken::new("x")?), "AccessToken(***)");
assert_eq!(format!("{:?}", ClientId::new("x")?), "ClientId(\"x\")");
Ok(())
}
#[test]
fn environment_parses_and_prints() {
assert_eq!("demo".parse(), Ok(Environment::Demo));
assert_eq!("live".parse(), Ok(Environment::Live));
assert_eq!(
"paper".parse::<Environment>(),
Err(ConfigError::InvalidEnvironment("paper".to_owned()))
);
assert_eq!(Environment::Demo.to_string(), "demo");
assert_eq!(Environment::Live.to_string(), "live");
assert_eq!(Environment::default(), Environment::Demo);
}
#[test]
fn lookup_with_required_values_gives_demo_defaults() -> Result<(), ConfigError> {
let configuration = ConfigurationOpenApi::from_lookup(lookup(&REQUIRED))?;
let expected = filled(ConfigurationOpenApi::builder()).build()?;
assert_eq!(configuration, expected);
Ok(())
}
#[test]
fn lookup_applies_optional_values() -> Result<(), ConfigError> {
let configuration = ConfigurationOpenApi::from_lookup(lookup(&with(&[
(ENV_REFRESH_TOKEN, "refresh"),
(ENV_DEMO_HOST, "demo.example.test"),
(ENV_TOKEN_URL, "https://auth.example.test/token"),
(ENV_ENVIRONMENT, "demo"),
])))?;
assert_eq!(configuration.environment(), Environment::Demo);
assert_eq!(configuration.host(), "demo.example.test");
assert_eq!(configuration.token_url(), "https://auth.example.test/token");
assert_eq!(
configuration.refresh_token().map(RefreshToken::expose),
Some("refresh")
);
Ok(())
}
#[test]
fn lookup_ignores_the_demo_host_when_live() -> Result<(), ConfigError> {
let configuration = ConfigurationOpenApi::from_lookup(lookup(&with(&[
(ENV_DEMO_HOST, "demo.example.test"),
(ENV_ENVIRONMENT, "live"),
])))?;
assert_eq!(configuration.environment(), Environment::Live);
assert_eq!(configuration.host(), LIVE_HOST);
Ok(())
}
#[test]
fn lookup_treats_empty_values_as_absent() -> Result<(), ConfigError> {
let configuration = ConfigurationOpenApi::from_lookup(lookup(&with(&[
(ENV_REFRESH_TOKEN, ""),
(ENV_DEMO_HOST, ""),
(ENV_TOKEN_URL, ""),
(ENV_ENVIRONMENT, ""),
])))?;
let expected = filled(ConfigurationOpenApi::builder()).build()?;
assert_eq!(configuration, expected);
Ok(())
}
#[test]
fn lookup_names_the_missing_variable() {
for missing in [ENV_CLIENT_ID, ENV_CLIENT_SECRET, ENV_ACCESS_TOKEN] {
let pairs: Vec<_> = REQUIRED
.iter()
.filter(|(key, _)| *key != missing)
.copied()
.collect();
assert_eq!(
ConfigurationOpenApi::from_lookup(lookup(&pairs)),
Err(ConfigError::Missing(missing))
);
}
}
#[test]
fn lookup_rejects_bad_values() {
assert_eq!(
ConfigurationOpenApi::from_lookup(lookup(&with(&[(ENV_ENVIRONMENT, "paper")]))),
Err(ConfigError::InvalidEnvironment("paper".to_owned()))
);
assert_eq!(
ConfigurationOpenApi::from_lookup(lookup(&with(&[(ENV_DEMO_HOST, "a b")]))),
Err(ConfigError::InvalidHost("a b".to_owned()))
);
assert_eq!(
ConfigurationOpenApi::from_lookup(lookup(&with(&[(ENV_TOKEN_URL, "ftp://x")]))),
Err(ConfigError::InvalidTokenUrl("ftp://x".to_owned()))
);
}
#[test]
fn process_environment_is_read_through_the_same_lookup() {
let direct = ConfigurationOpenApi::from_lookup(|key| std::env::var(key).ok());
assert_eq!(ConfigurationOpenApi::from_env(), direct);
}
#[test]
fn errors_describe_the_rejected_value() {
assert_eq!(
ConfigError::Missing("client_id").to_string(),
"client_id is not set"
);
assert_eq!(
ConfigError::InvalidEnvironment("paper".to_owned()).to_string(),
"environment must be demo or live, got paper"
);
assert_eq!(
ConfigError::InvalidHost("a b".to_owned()).to_string(),
"host is not a bare host name: a b"
);
assert_eq!(
ConfigError::InvalidPort.to_string(),
"port must not be zero"
);
assert_eq!(
ConfigError::InvalidTokenUrl("x".to_owned()).to_string(),
"token URL must be an https URL: x"
);
assert_eq!(
ConfigError::ZeroDuration("timeout").to_string(),
"timeout must be longer than zero"
);
assert_eq!(
ConfigError::TooLong {
option: "heartbeat",
limit: MAX_FIX_HEARTBEAT,
}
.to_string(),
"heartbeat must not be longer than 3600 s"
);
}
fn fix() -> ConfigurationFixBuilder {
ConfigurationFix::builder()
.host("fix.example.com")
.sender_comp_id("demo.broker.4242")
.username("4242")
.password("open-sesame")
}
const FIX_REQUIRED: [(&str, &str); 4] = [
(ENV_FIX_HOST, "fix.example.com"),
(ENV_FIX_SENDER_COMP_ID, "demo.broker.4242"),
(ENV_FIX_USERNAME, "4242"),
(ENV_FIX_PASSWORD, "open-sesame"),
];
fn fix_with(extra: &[(&'static str, &'static str)]) -> Vec<(&'static str, &'static str)> {
FIX_REQUIRED.iter().chain(extra).copied().collect()
}
#[test]
fn fix_builder_defaults_to_tls_and_the_documented_ports() -> Result<(), ConfigError> {
let configuration = fix().build()?;
assert_eq!(configuration.host(), "fix.example.com");
assert!(configuration.encrypted());
assert_eq!(configuration.quote_port(), DEFAULT_FIX_QUOTE_PORT);
assert_eq!(configuration.trade_port(), DEFAULT_FIX_TRADE_PORT);
assert_eq!(configuration.sender_comp_id(), "demo.broker.4242");
assert_eq!(configuration.target_comp_id(), DEFAULT_FIX_TARGET_COMP_ID);
assert_eq!(configuration.username(), "4242");
assert_eq!(configuration.password().expose(), "open-sesame");
assert_eq!(configuration.heartbeat(), DEFAULT_FIX_HEARTBEAT);
assert_eq!(configuration.timeout(), DEFAULT_TIMEOUT);
assert_eq!(configuration.reconnect_delay(), DEFAULT_RECONNECT_DELAY);
Ok(())
}
#[test]
fn fix_sessions_run_unencrypted_only_on_request() -> Result<(), ConfigError> {
let plain = fix().unencrypted().build()?;
assert!(!plain.encrypted());
assert_eq!(plain.quote_port(), DEFAULT_FIX_QUOTE_PLAIN_PORT);
assert_eq!(plain.trade_port(), DEFAULT_FIX_TRADE_PLAIN_PORT);
let chosen = fix().unencrypted().quote_port(1).trade_port(2).build()?;
assert_eq!((chosen.quote_port(), chosen.trade_port()), (1, 2));
Ok(())
}
#[test]
fn fix_builder_takes_every_setting() -> Result<(), ConfigError> {
let configuration = fix()
.target_comp_id("cServer")
.heartbeat(Duration::from_millis(5_900))
.timeout(Duration::from_secs(3))
.reconnect_delay(Duration::from_secs(4))
.build()?;
assert_eq!(configuration.target_comp_id(), "cServer");
assert_eq!(configuration.heartbeat(), Duration::from_secs(5));
assert_eq!(configuration.timeout(), Duration::from_secs(3));
assert_eq!(configuration.reconnect_delay(), Duration::from_secs(4));
let slowest = fix().heartbeat(MAX_FIX_HEARTBEAT).build()?;
assert_eq!(slowest.heartbeat(), MAX_FIX_HEARTBEAT);
Ok(())
}
#[test]
fn fix_reconnect_delay_is_bounded_at_one_hour() {
assert_eq!(MAX_FIX_RECONNECT_DELAY, Duration::from_secs(3_600));
}
#[test]
fn fix_builder_shortens_a_reconnect_delay_above_the_maximum() -> Result<(), ConfigError> {
let longest = fix().reconnect_delay(MAX_FIX_RECONNECT_DELAY).build()?;
assert_eq!(longest.reconnect_delay(), MAX_FIX_RECONNECT_DELAY);
let above = MAX_FIX_RECONNECT_DELAY + Duration::from_nanos(1);
for delay in [above, Duration::MAX] {
let configuration = fix().reconnect_delay(delay).build()?;
assert_eq!(configuration.reconnect_delay(), MAX_FIX_RECONNECT_DELAY);
}
let below = MAX_FIX_RECONNECT_DELAY - Duration::from_nanos(1);
assert_eq!(
fix().reconnect_delay(below).build()?.reconnect_delay(),
below
);
Ok(())
}
#[test]
fn fix_builder_rejects_absent_and_invalid_values() {
let cases = [
(
ConfigurationFix::builder().build(),
ConfigError::Missing("host"),
),
(
fix().host("a host").build(),
ConfigError::InvalidHost("a host".to_owned()),
),
(
fix().sender_comp_id(" ").build(),
ConfigError::Missing("sender_comp_id"),
),
(
fix().target_comp_id("").build(),
ConfigError::Missing("target_comp_id"),
),
(fix().username("").build(), ConfigError::Missing("username")),
(
fix().password("").build(),
ConfigError::Missing("fix_password"),
),
(fix().quote_port(0).build(), ConfigError::InvalidPort),
(fix().trade_port(0).build(), ConfigError::InvalidPort),
(
fix().heartbeat(Duration::from_millis(999)).build(),
ConfigError::ZeroDuration("heartbeat"),
),
(
fix()
.heartbeat(MAX_FIX_HEARTBEAT + Duration::from_secs(1))
.build(),
ConfigError::TooLong {
option: "heartbeat",
limit: MAX_FIX_HEARTBEAT,
},
),
(
fix().heartbeat(Duration::MAX).build(),
ConfigError::TooLong {
option: "heartbeat",
limit: MAX_FIX_HEARTBEAT,
},
),
(
fix().timeout(Duration::ZERO).build(),
ConfigError::ZeroDuration("timeout"),
),
(
fix().reconnect_delay(Duration::ZERO).build(),
ConfigError::ZeroDuration("reconnect_delay"),
),
];
for (built, expected) in cases {
assert_eq!(built, Err(expected));
}
}
#[test]
fn fix_configuration_is_read_from_variables() -> Result<(), ConfigError> {
let plain = ConfigurationFix::from_lookup(lookup(&FIX_REQUIRED))?;
assert_eq!(plain, fix().build()?);
let full = ConfigurationFix::from_lookup(lookup(&fix_with(&[
(ENV_FIX_QUOTE_PORT, " 6001 "),
(ENV_FIX_TRADE_PORT, "6002"),
(ENV_FIX_TARGET_COMP_ID, "cServer"),
])))?;
assert_eq!((full.quote_port(), full.trade_port()), (6001, 6002));
assert_eq!(full.target_comp_id(), "cServer");
let blank = ConfigurationFix::from_lookup(lookup(&fix_with(&[
(ENV_FIX_QUOTE_PORT, " "),
(ENV_FIX_TARGET_COMP_ID, ""),
])))?;
assert_eq!(blank, plain);
Ok(())
}
#[test]
fn fix_variables_that_are_absent_or_invalid_are_rejected() {
for (index, (key, _)) in FIX_REQUIRED.iter().enumerate() {
let rest: Vec<_> = FIX_REQUIRED
.iter()
.enumerate()
.filter(|(other, _)| *other != index)
.map(|(_, pair)| *pair)
.collect();
assert_eq!(
ConfigurationFix::from_lookup(lookup(&rest)),
Err(ConfigError::Missing(key))
);
}
for (key, value) in [
(ENV_FIX_QUOTE_PORT, "0"),
(ENV_FIX_QUOTE_PORT, "70000"),
(ENV_FIX_TRADE_PORT, "port"),
] {
assert_eq!(
ConfigurationFix::from_lookup(lookup(&fix_with(&[(key, value)]))),
Err(ConfigError::InvalidPort)
);
}
}
#[test]
fn fix_password_never_appears_in_debug_output() -> Result<(), ConfigError> {
let shown = format!("{:?} {:?}", fix(), fix().build()?);
assert!(!shown.contains("open-sesame"), "{shown}");
assert!(shown.contains("FixPassword(***)"), "{shown}");
Ok(())
}
}