#[cfg(test)]
mod tests {
use anyhow::{anyhow, Result};
use cryptocurrency_parser::BlockchainParser;
use cryptocurrency_parser::Rule;
use pest::Parser;
#[test]
fn test_digit() -> Result<()> {
let valid_input = "5";
match BlockchainParser::parse(Rule::digit, valid_input) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
println!("Parsed digit: {}", pair.as_str());
}
assert!(true, "Expected valid input to match the digit rule");
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "a";
match BlockchainParser::parse(Rule::digit, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to fail the digit rule");
}
}
Ok(())
}
#[test]
fn test_year() -> Result<()> {
let valid_input = "2023";
match BlockchainParser::parse(Rule::year, valid_input) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
println!("Parsed year: {}", pair.as_str());
}
assert!(true, "Expected valid input to match the year rule");
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "20a3";
match BlockchainParser::parse(Rule::year, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to fail the year rule");
}
}
Ok(())
}
#[test]
fn test_month() -> Result<()> {
let valid_input = "09";
match BlockchainParser::parse(Rule::month, valid_input) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
println!("Parsed month: {}", pair.as_str());
}
assert!(true, "Expected valid input to match the month rule");
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "december";
match BlockchainParser::parse(Rule::month, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to fail the month rule");
}
}
Ok(())
}
#[test]
fn test_day() -> Result<()> {
let valid_input = "15";
match BlockchainParser::parse(Rule::day, valid_input) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
println!("Parsed day: {}", pair.as_str());
}
assert!(true, "Expected valid input to match the day rule");
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "fifteen";
match BlockchainParser::parse(Rule::day, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to fail the day rule");
}
}
Ok(())
}
#[test]
fn test_date() -> Result<()> {
let valid_input_dot_format = "31.12.2023";
let valid_input_slash_format = "12/31/2023";
match BlockchainParser::parse(Rule::date, valid_input_dot_format) {
Ok(_) => {
println!("Parsing succeeded for dot-separated date format");
assert!(
true,
"Expected valid input to match the dot-separated date format"
);
}
Err(e) => {
return Err(anyhow!(
"Parsing failed for dot-separated date format: {:?}",
e
));
}
}
match BlockchainParser::parse(Rule::date, valid_input_slash_format) {
Ok(_) => {
println!("Parsing succeeded for slash-separated date format");
assert!(
true,
"Expected valid input to match the slash-separated date format"
);
}
Err(e) => {
return Err(anyhow!(
"Parsing failed for slash-separated date format: {:?}",
e
));
}
}
let invalid_input = "31-12-2023";
match BlockchainParser::parse(Rule::date, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to not match the date rule");
}
}
Ok(())
}
#[test]
fn test_blockchain_name() -> Result<()> {
let valid_input = "BTC";
match BlockchainParser::parse(Rule::blockchain_name, valid_input) {
Ok(_) => {
println!("Parsing succeeded for valid input");
assert!(
true,
"Expected valid input to match the blockchain_name rule"
);
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "XRP";
match BlockchainParser::parse(Rule::blockchain_name, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(
true,
"Expected invalid input to not match the blockchain_name rule"
);
}
}
Ok(())
}
#[test]
fn test_currency() -> Result<()> {
let valid_input = "UAH";
match BlockchainParser::parse(Rule::currency, valid_input) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
println!("Parsed currency: {}", pair.as_str());
}
assert!(true, "Expected valid input to match the currency rule");
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "GBP";
match BlockchainParser::parse(Rule::currency, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to fail the currency rule");
}
}
Ok(())
}
#[test]
fn test_number() -> Result<()> {
let valid_input = "1,234,567,899";
match BlockchainParser::parse(Rule::number, valid_input) {
Ok(_) => {
println!("Parsing succeeded for valid input");
assert!(true, "Expected valid input to match the number rule");
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = ".67";
match BlockchainParser::parse(Rule::number, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to not match the number rule");
}
}
Ok(())
}
#[test]
fn test_number_and_currency() -> Result<()> {
let valid_input = "100 USD";
match BlockchainParser::parse(Rule::number_and_currency, valid_input) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
println!("Parsed number and currency: {}", pair.as_str());
}
assert!(
true,
"Expected valid input to match the number_and_currency rule"
);
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "100 GBP";
match BlockchainParser::parse(Rule::number_and_currency, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(
true,
"Expected invalid input to fail the number_and_currency rule"
);
}
}
Ok(())
}
#[test]
fn test_entry_format() -> Result<()> {
let valid_input = "Name: BTC; Date: 31.12.2023; Open: 234.56 USD; Close: 234.56 USD; High: 300.00 USD; Low: 200.00 USD; Volume: 500,000,000 USD;";
match BlockchainParser::parse(Rule::entry, valid_input) {
Ok(_) => {
println!("Parsing succeeded for valid input");
assert!(true, "Expected valid input to match the entry rule");
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "Name: BTC; Date: 31-12-2023; Open: 1,234.56 USD; Close: 1,234.56 USD; High: 1,300.00 USD; Low: 1,200.00 USD; Volume: 500000 USD";
match BlockchainParser::parse(Rule::entry, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to not match the entry rule");
}
}
Ok(())
}
#[test]
fn test_name() -> Result<()> {
let valid_input = "Name: BTC;";
match BlockchainParser::parse(Rule::name, valid_input) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
if let Some(inner_pair) = pair.into_inner().next() {
println!("Parsed name: {}", inner_pair.as_str());
}
}
assert!(true, "Expected valid input to match the name rule");
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "Name: DOGE;";
match BlockchainParser::parse(Rule::name, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to fail the name rule");
}
}
Ok(())
}
#[test]
fn test_date_entry() -> Result<()> {
let valid_input_1 = "Date: 25.12.2023;";
match BlockchainParser::parse(Rule::date_entry, valid_input_1) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
println!("Parsed date entry (format 1): {}", pair.as_str());
}
assert!(
true,
"Expected valid input to match the date_entry rule (format 1)"
);
}
Err(e) => {
return Err(anyhow!(
"Parsing failed for valid input (format 1): {:?}",
e
));
}
}
let valid_input_2 = "Date: 12/25/2023;";
match BlockchainParser::parse(Rule::date_entry, valid_input_2) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
println!("Parsed date entry (format 2): {}", pair.as_str());
}
assert!(
true,
"Expected valid input to match the date_entry rule (format 2)"
);
}
Err(e) => {
return Err(anyhow!(
"Parsing failed for valid input (format 2): {:?}",
e
));
}
}
let invalid_input = "Date: 25-12-23;";
match BlockchainParser::parse(Rule::date_entry, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to fail the date_entry rule");
}
}
Ok(())
}
#[test]
fn test_open() -> Result<()> {
let valid_input = "Open: 200.34 USD;";
match BlockchainParser::parse(Rule::open, valid_input) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
if let Some(inner_pair) = pair.into_inner().next() {
println!("Parsed open: {}", inner_pair.as_str());
}
}
assert!(true, "Expected valid input to match the open rule");
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "Open: two hundred USD;";
match BlockchainParser::parse(Rule::open, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to fail the open rule");
}
}
Ok(())
}
#[test]
fn test_close() -> Result<()> {
let valid_input = "Close: 200.34 USD;";
match BlockchainParser::parse(Rule::close, valid_input) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
if let Some(inner_pair) = pair.into_inner().next() {
println!("Parsed close: {}", inner_pair.as_str());
}
}
assert!(true, "Expected valid input to match the close rule");
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "Close: two hundred USD;";
match BlockchainParser::parse(Rule::close, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to fail the close rule");
}
}
Ok(())
}
#[test]
fn test_high() -> Result<()> {
let valid_input = "High: 30000 USD;";
match BlockchainParser::parse(Rule::high, valid_input) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
println!("Parsed high value: {}", pair.as_str());
}
assert!(true, "Expected valid input to match the high rule");
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "High: thirty thousand USD;";
match BlockchainParser::parse(Rule::high, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to fail the high rule");
}
}
Ok(())
}
#[test]
fn test_low() -> Result<()> {
let valid_input = "Low: 30000 USD;";
match BlockchainParser::parse(Rule::low, valid_input) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
println!("Parsed low value: {}", pair.as_str());
}
assert!(true, "Expected valid input to match the low rule");
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "Low: thirty thousand USD;";
match BlockchainParser::parse(Rule::low, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to fail the low rule");
}
}
Ok(())
}
#[test]
fn test_volume() -> Result<()> {
let valid_input = "Volume: 9,822,932,731 USD;";
match BlockchainParser::parse(Rule::volume, valid_input) {
Ok(mut parsed) => {
if let Some(pair) = parsed.next() {
println!("Parsed volume value: {}", pair.as_str());
}
assert!(true, "Expected valid input to match the volume rule");
}
Err(e) => {
return Err(anyhow!("Parsing failed for valid input: {:?}", e));
}
}
let invalid_input = "Volume: five hundred thousand USD;";
match BlockchainParser::parse(Rule::volume, invalid_input) {
Ok(_) => {
return Err(anyhow!("Parsing succeeded unexpectedly for invalid input"));
}
Err(e) => {
println!("Parsing failed as expected for invalid input: {:?}", e);
assert!(true, "Expected invalid input to fail the volume rule");
}
}
Ok(())
}
}