use crate::datadictionary::{DataDictionary, FieldDef, TagSet};
use crate::errors::*;
use crate::field::FieldValueReader;
use crate::field_map::FieldMap;
use crate::fix_float::FIXFloat;
use crate::fix_utc_timestamp::FIXUTCTimestamp;
use crate::message::Message;
use crate::msg_type::is_admin_message_type;
use crate::tag::*;
use crate::tag_value::TagValue;
use enum_dispatch::enum_dispatch;
use std::sync::Arc;
#[enum_dispatch]
pub trait Validator {
fn validate(&self, msg: &Message) -> MessageRejectErrorResult;
}
const USER_DEFINED_TAG_MIN: Tag = 5000;
#[allow(clippy::struct_excessive_bools)]
pub struct ValidatorSettings {
pub check_fields_out_of_order: bool,
pub reject_invalid_message: bool,
pub allow_unknown_message_fields: bool,
pub check_user_defined_fields: bool,
pub check_fields_have_values: bool,
}
impl Default for ValidatorSettings {
fn default() -> Self {
ValidatorSettings {
check_fields_out_of_order: true,
check_fields_have_values: true,
reject_invalid_message: true,
allow_unknown_message_fields: false,
check_user_defined_fields: true,
}
}
}
#[derive(Default)]
pub struct FixValidator {
data_dictionary: Arc<DataDictionary>,
settings: ValidatorSettings,
}
impl Validator for FixValidator {
fn validate(&self, msg: &Message) -> MessageRejectErrorResult {
if !msg.header.has(TAG_MSG_TYPE) {
return Err(required_tag_missing(TAG_MSG_TYPE));
}
let msg_type = msg.header.get_string(TAG_MSG_TYPE)?;
validate_fix(&self.data_dictionary, &self.settings, &msg_type, msg)
}
}
#[derive(Default)]
pub struct FixtValidator {
transport_data_dictionary: Arc<DataDictionary>,
app_data_dictionary: Arc<DataDictionary>,
settings: ValidatorSettings,
}
impl Validator for FixtValidator {
fn validate(&self, msg: &Message) -> MessageRejectErrorResult {
if !msg.header.has(TAG_MSG_TYPE) {
return Err(required_tag_missing(TAG_MSG_TYPE));
}
let msg_type = msg.header.get_string(TAG_MSG_TYPE)?;
if is_admin_message_type(msg_type.as_bytes()) {
return validate_fix(
&self.transport_data_dictionary,
&self.settings,
&msg_type,
msg,
);
}
validate_fixt(
&self.transport_data_dictionary,
&self.app_data_dictionary,
&self.settings,
&msg_type,
msg,
)
}
}
fn validate_fix(
d: &DataDictionary,
settings: &ValidatorSettings,
msg_type: &str,
msg: &Message,
) -> MessageRejectErrorResult {
validate_msg_type(d, msg_type, msg)?;
validate_required(d, d, msg_type, msg)?;
validate_field_content(msg, settings.check_fields_have_values, settings.check_fields_out_of_order)?;
if settings.reject_invalid_message {
validate_fields(d, d, settings, msg_type, msg)?;
validate_walk(d, d, settings, msg_type, msg)?;
}
Ok(())
}
fn validate_fixt(
transport_dd: &DataDictionary,
app_dd: &DataDictionary,
settings: &ValidatorSettings,
msg_type: &str,
msg: &Message,
) -> MessageRejectErrorResult {
validate_msg_type(app_dd, msg_type, msg)?;
validate_required(transport_dd, app_dd, msg_type, msg)?;
validate_field_content(msg, settings.check_fields_have_values, settings.check_fields_out_of_order)?;
if settings.reject_invalid_message {
validate_fields(transport_dd, app_dd, settings, msg_type, msg)?;
validate_walk(transport_dd, app_dd, settings, msg_type, msg)?;
}
Ok(())
}
fn validate_msg_type(
d: &DataDictionary,
msg_type: &str,
_msg: &Message,
) -> MessageRejectErrorResult {
if !d.messages.contains_key(msg_type) {
return Err(invalid_message_type());
}
Ok(())
}
fn validate_walk(
transport_dd: &DataDictionary,
app_dd: &DataDictionary,
settings: &ValidatorSettings,
msg_type: &str,
msg: &Message,
) -> MessageRejectErrorResult {
let mut iterated_tags = TagSet::new();
let mut fields: &[TagValue] = &msg.fields;
while !fields.is_empty() {
let field = fields.first().unwrap();
let tag = field.tag;
let message_def = if tag.is_header() {
&transport_dd.header
} else if tag.is_trailer() {
&transport_dd.trailer
} else {
app_dd.messages.get(msg_type).unwrap()
};
if iterated_tags.0.contains(&tag) {
return Err(tag_appears_more_than_once(tag));
}
iterated_tags.add(tag);
if let Some(field_def) = message_def.fields.get(&tag) {
fields = validate_visit_field(field_def, fields)?;
} else {
if !check_field_not_defined(settings, tag) {
return Err(tag_not_defined_for_this_message_type(tag));
}
fields = fields.get(1..).unwrap();
}
}
if !fields.is_empty() {
return Err(tag_not_defined_for_this_message_type(
fields.first().unwrap().tag,
));
}
Ok(())
}
fn validate_visit_field<'a>(
field_def: &FieldDef,
fields: &'a [TagValue],
) -> Result<&'a [TagValue], MessageRejectErrorEnum> {
if field_def.is_group() {
return validate_visit_group_field(field_def, fields);
}
Ok(fields.get(1..).unwrap())
}
fn validate_visit_group_field<'a>(
field_def: &FieldDef,
field_stack: &'a [TagValue],
) -> Result<&'a [TagValue], MessageRejectErrorEnum> {
let first_field_stack = field_stack.first().unwrap();
let num_in_group_tag = first_field_stack.tag;
let num_in_group: isize = atoi_simd::parse::<isize, false, false>(first_field_stack.value())
.map_err(|_| incorrect_data_format_for_value(num_in_group_tag))?;
let mut field_stack = field_stack.get(1..).unwrap();
let mut child_defs: Vec<FieldDef> = vec![];
let mut group_count = 0;
while !field_stack.is_empty() {
if field_stack.first().unwrap().tag == field_def.fields[0].tag() {
child_defs.clone_from(&field_def.fields);
group_count += 1;
}
if child_defs.is_empty() {
break;
}
if field_stack.first().unwrap().tag == child_defs[0].tag() {
field_stack = validate_visit_field(&child_defs[0], field_stack)?;
} else if child_defs[0].required() {
return Err(required_tag_missing(child_defs[0].tag()));
}
child_defs = child_defs[1..].to_vec();
}
if group_count != num_in_group {
return Err(incorrect_num_in_group_count_for_repeating_group(
num_in_group_tag,
));
}
Ok(field_stack)
}
fn validate_field_content(
msg: &Message,
check_fields_have_values: bool,
check_fields_out_of_order: bool,
) -> MessageRejectErrorResult {
if !check_fields_have_values && !check_fields_out_of_order {
return Ok(());
}
let mut in_header = true;
let mut in_trailer = false;
for field in msg.fields.iter() {
let t = field.tag;
if check_fields_have_values && field.value().is_empty() {
return Err(tag_specified_without_a_value(t));
}
if in_header && t.is_header() {
} else if in_header && !t.is_header() {
in_header = false;
} else if !in_header && t.is_header() && check_fields_out_of_order {
return Err(tag_specified_out_of_required_order(t));
} else if t.is_trailer() {
in_trailer = true;
} else if in_trailer && !t.is_trailer() && check_fields_out_of_order {
return Err(tag_specified_out_of_required_order(t));
}
}
Ok(())
}
fn check_field_not_defined(settings: &ValidatorSettings, field: Tag) -> bool {
let fail = if field < USER_DEFINED_TAG_MIN {
!settings.allow_unknown_message_fields
} else {
settings.check_user_defined_fields
};
!fail
}
fn validate_required(
transport_dd: &DataDictionary,
app_dd: &DataDictionary,
msg_type: &str,
msg: &Message,
) -> MessageRejectErrorResult {
validate_required_field_map(
msg,
&transport_dd.header.required_tags,
&msg.header.field_map,
)?;
let required_tags = &app_dd.messages.get(msg_type).unwrap().required_tags;
validate_required_field_map(msg, required_tags, &msg.body.field_map)?;
validate_required_field_map(
msg,
&transport_dd.trailer.required_tags,
&msg.trailer.field_map,
)?;
Ok(())
}
pub fn validate_required_field_map(
_msg: &Message,
required_tags: &TagSet,
field_map: &FieldMap,
) -> MessageRejectErrorResult {
for required in &required_tags.0 {
if !field_map.has(*required) {
return Err(required_tag_missing(*required));
}
}
Ok(())
}
fn validate_fields(
transport_dd: &DataDictionary,
app_dd: &DataDictionary,
settings: &ValidatorSettings,
msg_type: &str,
msg: &Message,
) -> MessageRejectErrorResult {
for field in msg.fields.iter() {
if field.tag.is_header() {
validate_field(transport_dd, settings, &transport_dd.header.tags, field)?;
} else if field.tag.is_trailer() {
validate_field(transport_dd, settings, &transport_dd.trailer.tags, field)?;
} else {
let tags = &app_dd.messages.get(msg_type).unwrap().tags;
validate_field(app_dd, settings, tags, field)?;
}
}
Ok(())
}
fn validate_field(
d: &DataDictionary,
settings: &ValidatorSettings,
_valid_fields: &TagSet,
field: &TagValue,
) -> MessageRejectErrorResult {
let value = field.value();
if value.is_empty() {
return Err(tag_specified_without_a_value(field.tag));
}
let is_message_field = d.field_type_by_tag.contains_key(&field.tag);
if !is_message_field && !check_field_not_defined(settings, field.tag) {
return Err(invalid_tag_number(field.tag));
}
if !is_message_field {
return Ok(());
}
let field_type = d.field_type_by_tag.get(&field.tag).unwrap();
let allowed_values = &field_type.enums;
if !allowed_values.is_empty() {
let value_str = std::str::from_utf8(value).map_err(|_| value_is_incorrect(field.tag))?;
if !allowed_values.contains_key(value_str) {
return Err(value_is_incorrect(field.tag));
}
}
let valid = match field_type.r#type.as_str() {
"MULTIPLESTRINGVALUE"
| "MULTIPLEVALUESTRING"
| "MULTIPLECHARVALUE"
| "CHAR"
| "CURRENCY"
| "DATA"
| "MONTHYEAR"
| "LOCALMKTDATE"
| "DATE"
| "EXCHANGE"
| "LANGUAGE"
| "XMLDATA"
| "COUNTRY"
| "UTCTIMEONLY"
| "UTCDATEONLY"
| "UTCDATE"
| "TZTIMEONLY"
| "TZTIMESTAMP"
| "STRING" => true, "LENGTH" | "DAYOFMONTH" | "NUMINGROUP" | "SEQNUM" | "INT" => {
atoi_simd::parse::<isize, false, false>(value).is_ok()
}
"UTCTIMESTAMP" | "TIME" => FIXUTCTimestamp::default().read(value).is_ok(),
"QTY" | "QUANTITY" | "AMT" | "PRICE" | "PRICEOFFSET" | "PERCENTAGE" | "FLOAT" => {
FIXFloat::default().read(value).is_ok()
}
_ => value == b"Y" || value == b"N",
};
if !valid {
return Err(incorrect_data_format_for_value(field.tag));
}
Ok(())
}
#[enum_dispatch(Validator)]
pub enum ValidatorEnum {
Fix(FixValidator),
Fixt(FixtValidator),
}
impl Default for ValidatorEnum {
fn default() -> Self {
Self::Fix(FixValidator::default())
}
}
impl ValidatorEnum {
pub fn new(
settings: ValidatorSettings,
app_data_dictionary: Arc<DataDictionary>,
transport_data_dictionary: Option<Arc<DataDictionary>>,
) -> Self {
if let Some(transport_data_dictionary) = transport_data_dictionary {
return Self::Fixt(FixtValidator {
transport_data_dictionary,
app_data_dictionary,
settings,
});
}
Self::Fix(FixValidator {
data_dictionary: app_data_dictionary,
settings,
})
}
}
#[cfg(test)]
#[allow(clippy::items_after_statements)]
mod tests {
use super::*;
use crate::{
datadictionary::{DataDictionary, FieldType},
fix_int::FIXInt,
fix_string::FIXString,
fix_utc_timestamp::TimestampPrecision,
tag_value::TagValue,
};
use jiff::Timestamp;
struct ValidateTest<'a> {
name: &'a str,
validator: ValidatorEnum,
message_bytes: Vec<u8>,
expected_reject_reason: isize,
expected_ref_tag_id: Option<Tag>,
do_not_expect_reject: bool,
}
#[tokio::test]
async fn test_validate() {
let tests = vec![
tc_invalid_tag_number_header().await,
tc_invalid_tag_number_header_fix_t().await,
tc_invalid_tag_number_body().await,
tc_invalid_tag_number_body_fix_t().await,
tc_invalid_tag_number_trailer().await,
tc_invalid_tag_number_trailer_fix_t().await,
tc_tag_specified_without_a_value().await,
tc_tag_specified_without_a_value_fix_t().await,
tc_invalid_msg_type().await,
tc_invalid_msg_type_fix_t().await,
tc_value_is_incorrect().await,
tc_value_is_incorrect_fix_t().await,
tc_incorrect_data_format_for_value().await,
tc_incorrect_data_format_for_value_fix_t().await,
tc_tag_specified_out_of_required_order_header().await,
tc_tag_specified_out_of_required_order_header_fix_t().await,
tc_tag_specified_out_of_required_order_trailer().await,
tc_tag_specified_out_of_required_order_trailer_fix_t().await,
tc_tag_specified_out_of_required_order_disabled_header().await,
tc_tag_specified_out_of_required_order_disabled_header_fix_t().await,
tc_tag_specified_out_of_required_order_disabled_trailer().await,
tc_tag_specified_out_of_required_order_disabled_trailer_fix_t().await,
tc_tag_appears_more_than_once().await,
tc_tag_appears_more_than_once_fix_t().await,
tc_float_validation().await,
tc_float_validation_fix_t().await,
tc_tag_not_defined_for_message().await,
tc_tag_not_defined_for_message_fix_t().await,
tc_tag_is_defined_for_message().await,
tc_tag_is_defined_for_message_fix_t().await,
tc_field_not_found_body().await,
tc_field_not_found_body_fix_t().await,
tc_field_not_found_header().await,
tc_field_not_found_header_fix_t().await,
tc_invalid_tag_check_disabled().await,
tc_invalid_tag_check_disabled_fix_t().await,
tc_invalid_tag_check_enabled().await,
tc_invalid_tag_check_enabled_fix_t().await,
tc_allow_unknown_message_fields_enabled().await,
tc_allow_unknown_message_fields_enabled_fix_t().await,
tc_allow_unknown_message_fields_disabled().await,
tc_allow_unknown_message_fields_disabled_fix_t().await,
tc_check_user_defined_fields_enabled().await,
tc_check_user_defined_fields_enabled_fix_t().await,
tc_check_user_defined_fields_disabled().await,
tc_check_user_defined_fields_disabled_fix_t().await,
tc_tag_specified_without_a_value_validate_has_values().await,
tc_tag_specified_without_a_value_fix_t_validate_has_values().await,
];
for test in &tests {
let mut msg = Message::new();
let parse_error = msg.parse_message(&test.message_bytes);
assert!(parse_error.is_ok());
let reject_result = test.validator.validate(&msg);
match (&reject_result, test.do_not_expect_reject) {
(Ok(()), true) => continue,
(Ok(()), false) => panic!("{}: Expected reject", test.name),
(Err(e), true) => panic!("{}: Unexpected reject: {e:?}", test.name),
(Err(_), false) => {} }
let reject = reject_result.unwrap_err();
assert_eq!(
reject.reject_reason(),
test.expected_reject_reason,
"{}: Expected reason {} got {}",
test.name,
test.expected_reject_reason,
reject.reject_reason(),
);
match (reject.ref_tag_id(), test.expected_ref_tag_id) {
(None, None) => {} (Some(actual), None) => {
panic!("{}: Unexpected RefTag '{actual}'", test.name);
}
(None, Some(expected)) => {
panic!("{}: Expected RefTag '{expected}'", test.name);
}
(Some(actual), Some(expected)) => {
assert_eq!(
actual, expected,
"{}: Expected RefTag '{expected}' got '{actual}'",
test.name,
);
}
}
}
}
fn create_fix40_new_order_single() -> Message {
let mut msg = Message::new();
let now = Timestamp::now();
msg.header.set_field(TAG_MSG_TYPE, FIXString::from("D"));
msg.header
.set_field(TAG_BEGIN_STRING, FIXString::from("FIX.4.0"));
msg.header.set_field(TAG_BODY_LENGTH, FIXString::from("0"));
msg.header
.set_field(TAG_SENDER_COMP_ID, FIXString::from("0"));
msg.header
.set_field(TAG_TARGET_COMP_ID, FIXString::from("0"));
msg.header.set_field(TAG_MSG_SEQ_NUM, FIXString::from("0"));
msg.header
.set_field(TAG_SENDING_TIME, FIXUTCTimestamp::from_time(now));
msg.body.set_field(11, FIXString::from("A"));
msg.body.set_field(21, FIXString::from("1"));
msg.body.set_field(55, FIXString::from("A"));
msg.body.set_field(54, FIXString::from("1"));
msg.body.set_field(40, FIXString::from("1"));
msg.body.set_field(38, 5 as FIXInt);
msg.body.set_field(100, FIXString::from("0"));
msg.trailer.set_field(TAG_CHECK_SUM, FIXString::from("000"));
msg
}
fn create_fix43_new_order_single() -> Message {
let mut msg = Message::new();
let now = Timestamp::now();
msg.header.set_field(TAG_MSG_TYPE, FIXString::from("D"));
msg.header
.set_field(TAG_BEGIN_STRING, FIXString::from("FIX.4.3"));
msg.header.set_field(TAG_BODY_LENGTH, FIXString::from("0"));
msg.header
.set_field(TAG_SENDER_COMP_ID, FIXString::from("0"));
msg.header
.set_field(TAG_TARGET_COMP_ID, FIXString::from("0"));
msg.header.set_field(TAG_MSG_SEQ_NUM, FIXString::from("0"));
msg.header
.set_field(TAG_SENDING_TIME, FIXUTCTimestamp::from_time(now));
msg.body.set_field(11, FIXString::from("A"));
msg.body.set_field(21, FIXString::from("1"));
msg.body.set_field(55, FIXString::from("A"));
msg.body.set_field(54, FIXString::from("1"));
msg.body.set_field(38, 5 as FIXInt);
msg.body.set_field(40, FIXString::from("1"));
msg.body.set_field(60, FIXUTCTimestamp::from_time(now));
msg.trailer.set_field(TAG_CHECK_SUM, FIXString::from("000"));
msg
}
fn create_fix50sp2_new_order_single() -> Message {
let mut msg = Message::new();
let now = Timestamp::now();
msg.header.set_field(TAG_MSG_TYPE, FIXString::from("D"));
msg.header
.set_field(TAG_BEGIN_STRING, FIXString::from("FIXT.1.1"));
msg.header.set_field(TAG_BODY_LENGTH, FIXString::from("0"));
msg.header
.set_field(TAG_SENDER_COMP_ID, FIXString::from("0"));
msg.header
.set_field(TAG_TARGET_COMP_ID, FIXString::from("0"));
msg.header.set_field(TAG_MSG_SEQ_NUM, FIXString::from("0"));
msg.header
.set_field(TAG_SENDING_TIME, FIXUTCTimestamp::from_time(now));
msg.body.set_field(11, FIXString::from("A"));
msg.body.set_field(21, FIXString::from("1"));
msg.body.set_field(55, FIXString::from("A"));
msg.body.set_field(54, FIXString::from("1"));
msg.body.set_field(40, FIXString::from("1"));
msg.body.set_field(38, 5 as FIXInt);
msg.body.set_field(
60,
FIXUTCTimestamp::from_time_with_precision(now, TimestampPrecision::Nanos),
);
msg.body.set_field(100, FIXString::from("0"));
msg.trailer.set_field(TAG_CHECK_SUM, FIXString::from("000"));
msg
}
async fn tc_invalid_tag_number_header<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let mut invalid_header_field_message = create_fix40_new_order_single();
let tag = 9999 as Tag;
invalid_header_field_message
.header
.set_field(tag, FIXString::from("hello"));
let message_bytes = invalid_header_field_message.build();
ValidateTest {
name: "Invalid Tag Number Header",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_INVALID_TAG_NUMBER,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_invalid_tag_number_header_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut invalid_header_field_message = create_fix50sp2_new_order_single();
let tag = 9999 as Tag;
invalid_header_field_message
.header
.set_field(tag, FIXString::from("hello"));
let message_bytes = invalid_header_field_message.build();
ValidateTest {
name: "Invalid Tag Number Header FIXT",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_INVALID_TAG_NUMBER,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_invalid_tag_number_body<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let mut invalid_body_field_message = create_fix40_new_order_single();
let tag = 9999 as Tag;
invalid_body_field_message
.body
.set_field(tag, FIXString::from("hello"));
let message_bytes = invalid_body_field_message.build();
ValidateTest {
name: "Invalid Tag Number Body",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_INVALID_TAG_NUMBER,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_invalid_tag_number_body_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut invalid_body_field_message = create_fix50sp2_new_order_single();
let tag = 9999 as Tag;
invalid_body_field_message
.body
.set_field(tag, FIXString::from("hello"));
let message_bytes = invalid_body_field_message.build();
ValidateTest {
name: "Invalid Tag Number Body FIXT",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_INVALID_TAG_NUMBER,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_invalid_tag_number_trailer<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let mut invalid_trailer_field_message = create_fix40_new_order_single();
let tag = 9999 as Tag;
invalid_trailer_field_message
.trailer
.set_field(tag, FIXString::from("hello"));
let message_bytes = invalid_trailer_field_message.build();
ValidateTest {
name: "Invalid Tag Number Trailer",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_INVALID_TAG_NUMBER,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_invalid_tag_number_trailer_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut invalid_trailer_field_message = create_fix50sp2_new_order_single();
let tag = 9999 as Tag;
invalid_trailer_field_message
.trailer
.set_field(tag, FIXString::from("hello"));
let message_bytes = invalid_trailer_field_message.build();
ValidateTest {
name: "Invalid Tag Number Trailer FIXT",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_INVALID_TAG_NUMBER,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_tag_not_defined_for_message<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let mut invalid_msg = create_fix40_new_order_single();
let tag = 41 as Tag;
invalid_msg.body.set_field(tag, FIXString::from("hello"));
let message_bytes = invalid_msg.build();
ValidateTest {
name: "Tag Not Defined For Message",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_tag_not_defined_for_message_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut invalid_msg = create_fix50sp2_new_order_single();
let tag = 41 as Tag;
invalid_msg.body.set_field(tag, FIXString::from("hello"));
let message_bytes = invalid_msg.build();
ValidateTest {
name: "Tag Not Defined For Message FIXT",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_tag_is_defined_for_message<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX43.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let mut valid_msg = create_fix43_new_order_single();
let message_bytes = valid_msg.build();
ValidateTest {
name: "TagIsDefinedForMessage",
validator,
message_bytes,
do_not_expect_reject: true,
expected_reject_reason: REJECT_REASON_OTHER,
expected_ref_tag_id: None,
}
}
async fn tc_tag_is_defined_for_message_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut valid_msg = create_fix50sp2_new_order_single();
let message_bytes = valid_msg.build();
ValidateTest {
name: "TagIsDefinedForMessage FIXT",
validator,
message_bytes,
do_not_expect_reject: true,
expected_reject_reason: REJECT_REASON_OTHER,
expected_ref_tag_id: None,
}
}
async fn tc_field_not_found_body<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let mut invalid_msg1 = Message::new();
invalid_msg1
.header
.set_field(TAG_MSG_TYPE, FIXString::from("D"));
invalid_msg1
.header
.set_field(TAG_BEGIN_STRING, FIXString::from("FIX.4.0"));
invalid_msg1
.header
.set_field(TAG_BODY_LENGTH, FIXString::from("0"));
invalid_msg1
.header
.set_field(TAG_SENDER_COMP_ID, FIXString::from("0"));
invalid_msg1
.header
.set_field(TAG_TARGET_COMP_ID, FIXString::from("0"));
invalid_msg1
.header
.set_field(TAG_MSG_SEQ_NUM, FIXString::from("0"));
invalid_msg1.header.set_field(
TAG_SENDING_TIME,
FIXUTCTimestamp::from_time(Timestamp::now()),
);
invalid_msg1
.trailer
.set_field(TAG_CHECK_SUM, FIXString::from("000"));
invalid_msg1.body.set_field(11, FIXString::from("A"));
invalid_msg1.body.set_field(21, FIXString::from("A"));
invalid_msg1.body.set_field(55, FIXString::from("A"));
invalid_msg1.body.set_field(54, FIXString::from("A"));
invalid_msg1.body.set_field(38, FIXString::from("A"));
let tag = 40 as Tag;
let message_bytes = invalid_msg1.build();
ValidateTest {
name: "FieldNotFoundBody",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_REQUIRED_TAG_MISSING,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_field_not_found_body_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut invalid_msg1 = Message::new();
invalid_msg1
.header
.set_field(TAG_MSG_TYPE, FIXString::from("D"));
invalid_msg1
.header
.set_field(TAG_BEGIN_STRING, FIXString::from("FIXT.1.1"));
invalid_msg1
.header
.set_field(TAG_BODY_LENGTH, FIXString::from("0"));
invalid_msg1
.header
.set_field(TAG_SENDER_COMP_ID, FIXString::from("0"));
invalid_msg1
.header
.set_field(TAG_TARGET_COMP_ID, FIXString::from("0"));
invalid_msg1
.header
.set_field(TAG_MSG_SEQ_NUM, FIXString::from("0"));
invalid_msg1.header.set_field(
TAG_SENDING_TIME,
FIXUTCTimestamp::from_time(Timestamp::now()),
);
invalid_msg1
.trailer
.set_field(TAG_CHECK_SUM, FIXString::from("000"));
invalid_msg1.body.set_field(11 as Tag, FIXString::from("A"));
invalid_msg1.body.set_field(21 as Tag, FIXString::from("A"));
invalid_msg1.body.set_field(55 as Tag, FIXString::from("A"));
invalid_msg1.body.set_field(54 as Tag, FIXString::from("A"));
invalid_msg1.body.set_field(38 as Tag, FIXString::from("A"));
invalid_msg1
.body
.set_field(60 as Tag, FIXUTCTimestamp::from_time(Timestamp::now()));
let tag = 40 as Tag;
let message_bytes = invalid_msg1.build();
ValidateTest {
name: "FieldNotFoundBody FIXT",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_REQUIRED_TAG_MISSING,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_field_not_found_header<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let mut invalid_msg2 = Message::new();
invalid_msg2
.trailer
.set_field(TAG_CHECK_SUM, FIXString::from("000"));
invalid_msg2.body.set_field(11, FIXString::from("A"));
invalid_msg2.body.set_field(21, FIXString::from("A"));
invalid_msg2.body.set_field(55, FIXString::from("A"));
invalid_msg2.body.set_field(54, FIXString::from("A"));
invalid_msg2.body.set_field(38, FIXString::from("A"));
invalid_msg2
.header
.set_field(TAG_MSG_TYPE, FIXString::from("D"));
invalid_msg2
.header
.set_field(TAG_BEGIN_STRING, FIXString::from("FIX.4.0"));
invalid_msg2
.header
.set_field(TAG_BODY_LENGTH, FIXString::from("0"));
invalid_msg2
.header
.set_field(TAG_SENDER_COMP_ID, FIXString::from("0"));
invalid_msg2
.header
.set_field(TAG_TARGET_COMP_ID, FIXString::from("0"));
invalid_msg2
.header
.set_field(TAG_MSG_SEQ_NUM, FIXString::from("0"));
let tag = TAG_SENDING_TIME;
let message_bytes = invalid_msg2.build();
ValidateTest {
name: "FieldNotFoundHeader",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_REQUIRED_TAG_MISSING,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_field_not_found_header_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut invalid_msg2 = Message::new();
invalid_msg2
.trailer
.set_field(TAG_CHECK_SUM, FIXString::from("000"));
invalid_msg2.body.set_field(11 as Tag, FIXString::from("A"));
invalid_msg2.body.set_field(21 as Tag, FIXString::from("A"));
invalid_msg2.body.set_field(55 as Tag, FIXString::from("A"));
invalid_msg2.body.set_field(54 as Tag, FIXString::from("A"));
invalid_msg2.body.set_field(38 as Tag, FIXString::from("A"));
invalid_msg2
.header
.set_field(TAG_MSG_TYPE, FIXString::from("D"));
invalid_msg2
.header
.set_field(TAG_BEGIN_STRING, FIXString::from("FIXT.1.1"));
invalid_msg2
.header
.set_field(TAG_BODY_LENGTH, FIXString::from("0"));
invalid_msg2
.header
.set_field(TAG_SENDER_COMP_ID, FIXString::from("0"));
invalid_msg2
.header
.set_field(TAG_TARGET_COMP_ID, FIXString::from("0"));
invalid_msg2
.header
.set_field(TAG_MSG_SEQ_NUM, FIXString::from("0"));
let tag = TAG_SENDING_TIME;
let message_bytes = invalid_msg2.build();
ValidateTest {
name: "FieldNotFoundHeader FIXT",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_REQUIRED_TAG_MISSING,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_tag_specified_without_a_value<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
let bogus_tag = 109 as Tag;
builder.body.set_field(bogus_tag, FIXString::from(""));
let message_bytes = builder.build();
ValidateTest {
name: "Tag SpecifiedWithoutAValue",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_TAG_SPECIFIED_WITHOUT_A_VALUE,
expected_ref_tag_id: Some(bogus_tag),
do_not_expect_reject: false,
}
}
async fn tc_tag_specified_without_a_value_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
let bogus_tag = 109 as Tag;
builder.body.set_field(bogus_tag, FIXString::from(""));
let message_bytes = builder.build();
ValidateTest {
name: "Tag SpecifiedWithoutAValue FIXT",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_TAG_SPECIFIED_WITHOUT_A_VALUE,
expected_ref_tag_id: Some(bogus_tag),
do_not_expect_reject: false,
}
}
async fn tc_invalid_msg_type<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
builder.header.set_field(TAG_MSG_TYPE, FIXString::from("z"));
let message_bytes = builder.build();
ValidateTest {
name: "Invalid MsgType",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_INVALID_MSG_TYPE,
expected_ref_tag_id: None,
do_not_expect_reject: false,
}
}
async fn tc_invalid_msg_type_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
builder
.header
.set_field(TAG_MSG_TYPE, FIXString::from("zz"));
let message_bytes = builder.build();
ValidateTest {
name: "Invalid MsgType FIXT",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_INVALID_MSG_TYPE,
expected_ref_tag_id: None,
do_not_expect_reject: false,
}
}
async fn tc_value_is_incorrect<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let tag = 21 as Tag;
let mut builder = create_fix40_new_order_single();
builder.body.set_field(tag, FIXString::from("4"));
let message_bytes = builder.build();
ValidateTest {
name: "ValueIsIncorrect",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_VALUE_IS_INCORRECT,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_value_is_incorrect_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let tag = 21 as Tag;
let mut builder = create_fix50sp2_new_order_single();
builder.body.set_field(tag, FIXString::from("4"));
let message_bytes = builder.build();
ValidateTest {
name: "ValueIsIncorrect FIXT",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_VALUE_IS_INCORRECT,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_incorrect_data_format_for_value<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
let tag = 38 as Tag;
builder.body.set_field(tag, FIXString::from("+200.00"));
let message_bytes = builder.build();
ValidateTest {
name: "IncorrectDataFormatForValue",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_INCORRECT_DATA_FORMAT_FOR_VALUE,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_incorrect_data_format_for_value_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
let tag = 38 as Tag;
builder.body.set_field(tag, FIXString::from("+200.00"));
let message_bytes = builder.build();
ValidateTest {
name: "IncorrectDataFormatForValue FIXT",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_INCORRECT_DATA_FORMAT_FOR_VALUE,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_tag_specified_out_of_required_order_header<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
let tag = TAG_ON_BEHALF_OF_COMP_ID;
builder.body.set_field(tag, FIXString::from("CWB"));
let message_bytes = builder.build();
ValidateTest {
name: "Tag specified out of required order in Header",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_tag_specified_out_of_required_order_header_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
let tag = TAG_ON_BEHALF_OF_COMP_ID;
builder.body.set_field(tag, FIXString::from("CWB"));
let message_bytes = builder.build();
ValidateTest {
name: "Tag specified out of required order in Header FIXT",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_tag_specified_out_of_required_order_trailer<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
let tag = TAG_SIGNATURE;
builder.body.set_field(tag, FIXString::from("SIG"));
let message_bytes = builder.build();
let ref_tag = 100 as Tag;
ValidateTest {
name: "Tag specified out of required order in Trailer",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER,
expected_ref_tag_id: Some(ref_tag),
do_not_expect_reject: false,
}
}
async fn tc_tag_specified_out_of_required_order_trailer_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
let tag = TAG_SIGNATURE;
builder.body.set_field(tag, FIXString::from("SIG"));
let message_bytes = builder.build();
let ref_tag = 100 as Tag;
ValidateTest {
name: "Tag specified out of required order in Trailer FIXT",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER,
expected_ref_tag_id: Some(ref_tag),
do_not_expect_reject: false,
}
}
async fn tc_invalid_tag_check_disabled<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
reject_invalid_message: false,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(custom_validator_settings, Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
let tag = 9999 as Tag;
builder.body.set_field(tag, FIXString::from("hello"));
let message_bytes = builder.build();
ValidateTest {
name: "Invalid Tag Check - Disabled",
validator,
message_bytes,
do_not_expect_reject: true,
expected_reject_reason: REJECT_REASON_OTHER, expected_ref_tag_id: Some(666), }
}
async fn tc_invalid_tag_check_disabled_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
reject_invalid_message: false,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(
custom_validator_settings,
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
let tag = 9999 as Tag;
builder.body.set_field(tag, FIXString::from("hello"));
let message_bytes = builder.build();
ValidateTest {
name: "Invalid Tag Check - Disabled FIXT",
validator,
message_bytes,
do_not_expect_reject: true,
expected_reject_reason: REJECT_REASON_OTHER, expected_ref_tag_id: Some(666), }
}
async fn tc_invalid_tag_check_enabled<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
reject_invalid_message: true,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(custom_validator_settings, Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
let tag = 9999 as Tag;
builder.body.set_field(tag, FIXString::from("hello"));
let message_bytes = builder.build();
ValidateTest {
name: "Invalid Tag Check - Enabled",
validator,
message_bytes,
do_not_expect_reject: false,
expected_ref_tag_id: Some(tag),
expected_reject_reason: REJECT_REASON_INVALID_TAG_NUMBER, }
}
async fn tc_invalid_tag_check_enabled_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
reject_invalid_message: true,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(
custom_validator_settings,
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
let tag = 9999 as Tag;
builder.body.set_field(tag, FIXString::from("hello"));
let message_bytes = builder.build();
ValidateTest {
name: "Invalid Tag Check - Enabled FIXT",
validator,
message_bytes,
do_not_expect_reject: false,
expected_ref_tag_id: Some(tag),
expected_reject_reason: REJECT_REASON_INVALID_TAG_NUMBER, }
}
async fn tc_allow_unknown_message_fields_enabled<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
allow_unknown_message_fields: true,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(custom_validator_settings, Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
let tag = 41 as Tag;
builder.body.set_field(tag, FIXString::from("hello"));
let message_bytes = builder.build();
ValidateTest {
name: "Allow Unknown Message Fields - Enabled",
validator,
message_bytes,
do_not_expect_reject: true,
expected_reject_reason: REJECT_REASON_OTHER,
expected_ref_tag_id: None,
}
}
async fn tc_allow_unknown_message_fields_enabled_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
allow_unknown_message_fields: true,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(
custom_validator_settings,
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
let tag = 41 as Tag;
builder.body.set_field(tag, FIXString::from("hello"));
let message_bytes = builder.build();
ValidateTest {
name: "Allow Unknown Message Fields - Enabled FIXT",
validator,
message_bytes,
do_not_expect_reject: true,
expected_reject_reason: REJECT_REASON_OTHER,
expected_ref_tag_id: None,
}
}
async fn tc_allow_unknown_message_fields_disabled<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
allow_unknown_message_fields: false,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(custom_validator_settings, Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
let tag = 41 as Tag;
builder.body.set_field(tag, FIXString::from("hello"));
let message_bytes = builder.build();
ValidateTest {
name: "Allow Unknown Message Fields - Disabled",
validator,
message_bytes,
do_not_expect_reject: false,
expected_reject_reason: REJECT_REASON_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE,
expected_ref_tag_id: Some(tag),
}
}
async fn tc_allow_unknown_message_fields_disabled_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
reject_invalid_message: true,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(
custom_validator_settings,
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
let tag = 41 as Tag;
builder.body.set_field(tag, FIXString::from("hello"));
let message_bytes = builder.build();
ValidateTest {
name: "Allow Unknown Message Fields - Disabled FIXT",
validator,
message_bytes,
do_not_expect_reject: false,
expected_reject_reason: REJECT_REASON_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE,
expected_ref_tag_id: Some(tag),
}
}
async fn tc_check_user_defined_fields_enabled<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
check_user_defined_fields: true,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(custom_validator_settings, Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
let tag = 9999 as Tag;
builder.body.set_field(tag, FIXString::from("hello"));
let message_bytes = builder.build();
ValidateTest {
name: "Check User Defined Fields - Enabled",
validator,
message_bytes,
do_not_expect_reject: false,
expected_ref_tag_id: Some(tag),
expected_reject_reason: REJECT_REASON_INVALID_TAG_NUMBER,
}
}
async fn tc_check_user_defined_fields_enabled_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
reject_invalid_message: true,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(
custom_validator_settings,
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
let tag = 9999 as Tag;
builder.body.set_field(tag, FIXString::from("hello"));
let message_bytes = builder.build();
ValidateTest {
name: "Check User Defined Fields - Enabled FIXT",
validator,
message_bytes,
do_not_expect_reject: false,
expected_ref_tag_id: Some(tag),
expected_reject_reason: REJECT_REASON_INVALID_TAG_NUMBER,
}
}
async fn tc_check_user_defined_fields_disabled<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
check_user_defined_fields: false,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(custom_validator_settings, Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
let tag = 9999 as Tag;
builder.body.set_field(tag, FIXString::from("hello"));
let message_bytes = builder.build();
ValidateTest {
name: "Check User Defined Fields - Disabled",
validator,
message_bytes,
do_not_expect_reject: true,
expected_reject_reason: REJECT_REASON_OTHER,
expected_ref_tag_id: None,
}
}
async fn tc_check_user_defined_fields_disabled_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
check_user_defined_fields: false,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(
custom_validator_settings,
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
let tag = 9999 as Tag;
builder.body.set_field(tag, FIXString::from("hello"));
let message_bytes = builder.build();
ValidateTest {
name: "Check User Defined Fields - Disabled FIXT",
validator,
message_bytes,
do_not_expect_reject: true,
expected_reject_reason: REJECT_REASON_OTHER,
expected_ref_tag_id: None,
}
}
async fn tc_tag_specified_without_a_value_validate_has_values<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
reject_invalid_message: false,
check_fields_have_values: true,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(custom_validator_settings, Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
let bogus_tag = 109 as Tag;
builder.body.set_field(bogus_tag, FIXString::from(""));
let message_bytes = builder.build();
ValidateTest {
name: "Tag SpecifiedWithoutAValue ValidateHasValues",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_TAG_SPECIFIED_WITHOUT_A_VALUE,
expected_ref_tag_id: Some(bogus_tag),
do_not_expect_reject: false,
}
}
async fn tc_tag_specified_without_a_value_fix_t_validate_has_values<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
reject_invalid_message: false,
check_fields_have_values: true,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(
custom_validator_settings,
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
let bogus_tag = 109 as Tag;
builder.body.set_field(bogus_tag, FIXString::from(""));
let message_bytes = builder.build();
ValidateTest {
name: "Tag SpecifiedWithoutAValue FIXT ValidateHasValues",
validator,
message_bytes,
expected_reject_reason: REJECT_REASON_TAG_SPECIFIED_WITHOUT_A_VALUE,
expected_ref_tag_id: Some(bogus_tag),
do_not_expect_reject: false,
}
}
async fn tc_tag_specified_out_of_required_order_disabled_header<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
check_fields_out_of_order: false,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(custom_validator_settings, Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
let tag = TAG_ON_BEHALF_OF_COMP_ID;
builder.body.set_field(tag, FIXString::from("CWB"));
let message_bytes = builder.build();
ValidateTest {
name: "Tag specified out of required order in Header - Disabled",
validator,
message_bytes,
do_not_expect_reject: true,
expected_reject_reason: REJECT_REASON_OTHER, expected_ref_tag_id: Some(666), }
}
async fn tc_tag_specified_out_of_required_order_disabled_header_fix_t<'a>() -> ValidateTest<'a>
{
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
check_fields_out_of_order: false,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(
custom_validator_settings,
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
let tag = TAG_ON_BEHALF_OF_COMP_ID;
builder.body.set_field(tag, FIXString::from("CWB"));
let message_bytes = builder.build();
ValidateTest {
name: "Tag specified out of required order in Header - Disabled FIXT",
validator,
message_bytes,
do_not_expect_reject: true,
expected_reject_reason: REJECT_REASON_OTHER, expected_ref_tag_id: Some(666), }
}
async fn tc_tag_specified_out_of_required_order_disabled_trailer<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
check_fields_out_of_order: false,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(custom_validator_settings, Arc::new(dict), None);
let mut builder = create_fix40_new_order_single();
let tag = TAG_SIGNATURE;
builder.body.set_field(tag, FIXString::from("SIG"));
let message_bytes = builder.build();
ValidateTest {
name: "Tag specified out of required order in Trailer - Disabled",
validator,
message_bytes,
do_not_expect_reject: true,
expected_reject_reason: REJECT_REASON_OTHER, expected_ref_tag_id: Some(666), }
}
async fn tc_tag_specified_out_of_required_order_disabled_trailer_fix_t<'a>() -> ValidateTest<'a>
{
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let custom_validator_settings = ValidatorSettings {
check_fields_out_of_order: false,
..ValidatorSettings::default()
};
let validator = ValidatorEnum::new(
custom_validator_settings,
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let mut builder = create_fix50sp2_new_order_single();
let tag = TAG_SIGNATURE;
builder.body.set_field(tag, FIXString::from("SIG"));
let message_bytes = builder.build();
ValidateTest {
name: "Tag specified out of required order in Trailer - Disabled FIXT",
validator,
message_bytes,
do_not_expect_reject: true,
expected_reject_reason: REJECT_REASON_OTHER, expected_ref_tag_id: Some(666), }
}
async fn tc_tag_appears_more_than_once<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX40.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let tag = 40 as Tag;
ValidateTest {
name: "Tag appears more than once",
validator,
message_bytes: "8=FIX.4.09=10735=D34=249=TW52=20060102-15:04:0556=ISLD11=ID21=140=140=254=138=20055=INTC60=20060102-15:04:0510=234".into(),
expected_reject_reason: REJECT_REASON_TAG_APPEARS_MORE_THAN_ONCE,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_tag_appears_more_than_once_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let tag = 40 as Tag;
ValidateTest {
name: "Tag appears more than once FIXT",
validator,
message_bytes: "8=FIXT.1.19=10735=D34=249=TW52=20060102-15:04:0556=ISLD11=ID21=140=140=254=138=20055=INTC60=20060102-15:04:0510=234".into(),
expected_reject_reason: REJECT_REASON_TAG_APPEARS_MORE_THAN_ONCE,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_float_validation<'a>() -> ValidateTest<'a> {
let dict = DataDictionary::parse("../spec/FIX42.xml").await.unwrap();
let validator = ValidatorEnum::new(ValidatorSettings::default(), Arc::new(dict), None);
let tag = 38 as Tag;
ValidateTest {
name: "FloatValidation",
validator,
message_bytes: "8=FIX.4.29=10635=D34=249=TW52=20140329-22:38:4556=ISLD11=ID21=140=154=138=+200.0055=INTC60=20140329-22:38:4510=178".into(),
expected_reject_reason: REJECT_REASON_INCORRECT_DATA_FORMAT_FOR_VALUE,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
async fn tc_float_validation_fix_t<'a>() -> ValidateTest<'a> {
let t_dict = DataDictionary::parse("../spec/FIXT11.xml").await.unwrap();
let app_dict = DataDictionary::parse("../spec/FIX50SP2.xml").await.unwrap();
let validator = ValidatorEnum::new(
ValidatorSettings::default(),
Arc::new(app_dict),
Some(Arc::new(t_dict)),
);
let tag = 38 as Tag;
ValidateTest {
name: "FloatValidation FIXT",
validator,
message_bytes: "8=FIXT.1.19=10635=D34=249=TW52=20140329-22:38:4556=ISLD11=ID21=140=154=138=+200.0055=INTC60=20140329-22:38:4510=178".into(),
expected_reject_reason: REJECT_REASON_INCORRECT_DATA_FORMAT_FOR_VALUE,
expected_ref_tag_id: Some(tag),
do_not_expect_reject: false,
}
}
#[test]
fn test_validate_visit_field() {
let field_type0 = FieldType::new(String::from("myfield"), 11, String::from("STRING"));
let field_def0 = FieldDef::new(field_type0, false);
let field_type1 = FieldType::new(String::from("myfield"), 2, String::from("STRING"));
let field_def1 = FieldDef::new(field_type1, false);
let field_type2 = FieldType::new(String::from("myfield"), 3, String::from("STRING"));
let field_def2 = FieldDef::new(field_type2, false);
let group_field_type = FieldType::new(String::from("mygroupfield"), 1, String::from("INT"));
let mut group_field_def = FieldDef::new(group_field_type, false);
group_field_def.fields = vec![field_def1, field_def2];
let mut field = TagValue::default();
field.init(11 as Tag, "value".as_bytes());
let mut rep_field1 = TagValue::default();
rep_field1.init(2 as Tag, "a".as_bytes());
let mut rep_field2 = TagValue::default();
rep_field2.init(3 as Tag, "a".as_bytes());
let mut group_id = TagValue::default();
group_id.init(1 as Tag, "1".as_bytes());
let mut group_id2 = TagValue::default();
group_id2.init(1 as Tag, "2".as_bytes());
let mut group_id3 = TagValue::default();
group_id3.init(1 as Tag, "3".as_bytes());
#[derive(Default)]
struct TestCase {
field_def: FieldDef,
fields: Vec<TagValue>,
expected_rem_fields: usize,
expect_reject: bool,
expected_reject_reason: isize,
}
let test_cases = vec![
TestCase {
expected_rem_fields: 0,
field_def: field_def0,
fields: vec![field.clone()],
..Default::default()
},
TestCase {
expected_rem_fields: 0,
field_def: group_field_def.clone(),
fields: vec![group_id.clone(), rep_field1.clone()],
..Default::default()
},
TestCase {
expected_rem_fields: 0,
field_def: group_field_def.clone(),
fields: vec![group_id.clone(), rep_field1.clone(), rep_field2.clone()],
..Default::default()
},
TestCase {
expected_rem_fields: 1,
field_def: group_field_def.clone(),
fields: vec![
group_id.clone(),
rep_field1.clone(),
rep_field2.clone(),
field.clone(),
],
..Default::default()
},
TestCase {
expected_rem_fields: 1,
field_def: group_field_def.clone(),
fields: vec![
group_id2,
rep_field1.clone(),
rep_field2.clone(),
rep_field1.clone(),
rep_field2.clone(),
field.clone(),
],
..Default::default()
},
TestCase {
expect_reject: true,
field_def: group_field_def.clone(),
fields: vec![
group_id3.clone(),
rep_field1.clone(),
rep_field2.clone(),
rep_field1.clone(),
rep_field2.clone(),
field.clone(),
],
expected_reject_reason:
REJECT_REASON_INCORRECT_NUM_IN_GROUP_COUNT_FOR_REPEATING_GROUP,
..Default::default()
},
TestCase {
expect_reject: true,
field_def: group_field_def.clone(),
fields: vec![
group_id3.clone(),
rep_field1.clone(),
rep_field1.clone(),
field.clone(),
],
expected_reject_reason:
REJECT_REASON_INCORRECT_NUM_IN_GROUP_COUNT_FOR_REPEATING_GROUP,
..Default::default()
},
TestCase {
expect_reject: true,
field_def: group_field_def.clone(),
fields: vec![
group_id.clone(),
rep_field1.clone(),
rep_field2.clone(),
rep_field1.clone(),
rep_field2.clone(),
field.clone(),
],
expected_reject_reason:
REJECT_REASON_INCORRECT_NUM_IN_GROUP_COUNT_FOR_REPEATING_GROUP,
..Default::default()
},
];
for tc in &test_cases {
let validate_result = validate_visit_field(&tc.field_def, &tc.fields);
if tc.expect_reject {
assert!(validate_result.is_err(), "Expected Reject");
let reject = validate_result.unwrap_err();
assert_eq!(
reject.reject_reason(),
tc.expected_reject_reason,
"Expected reject reason {} got {}",
tc.expected_reject_reason,
reject.reject_reason()
);
} else {
assert!(
validate_result.is_ok(),
"Unexpected reject: {validate_result:?}",
);
let rem_fields = validate_result.unwrap();
assert_eq!(
rem_fields.len(),
tc.expected_rem_fields,
"Expected len {} got {}",
tc.expected_rem_fields,
rem_fields.len(),
);
}
}
}
}