jakob/rusty-petroleum
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Add comprehensive TDD infrastructure with 45 tests

Browse Source 
- Add lib crate exposing modules for integration testing
- Add dev-dependencies: tokio-test 0.4, tempfile
- Refactor parse_csv_fields() as pure function for unit testing
- Add field validation (minimum 16 fields required)
- Fix repository last_insert_id using SELECT LAST_INSERT_ID()
- Add 10 lib tests for CSV parsing and date formatting
- Add 10 config tests for environment configuration
- Add 7 import tests for CSV file parsing
- Add 6 models tests for database structs
- Add 12 repository tests for CRUD operations
This commit is contained in:
Jakob
2026-04-02 11:13:41 +02:00
parent 429d5d774f
commit e2123e4619
11 changed files with 1648 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
Cargo.toml
View File

@@ -3,6 +3,14 @@ name = "invoice-generator"
version = "0.1.0"
edition = "2021"
[lib]
name = "invoice_generator"
path = "src/lib.rs"
[[bin]]
name = "invoice-generator"
path = "src/main.rs"
[dependencies]
askama = "0.15.5"
chrono = { version = "0.4.44", features = ["serde"] }
@@ -13,3 +21,7 @@ tokio = { version = "1", features = ["full"] }
toml = "0.8"
anyhow = "1"
bigdecimal = { version = "0.4", features = ["serde"] }
[dev-dependencies]
tokio-test = "0.4"
tempfile = "3"

340
src/commands/import.rs
View File

@@ -6,6 +6,111 @@ use std::collections::HashMap;
use std::fs::File;
use std::path::Path;
/// Represents a parsed transaction from CSV fields.
///
/// AI AGENT NOTE: This is an intermediate struct for CSV parsing.
/// It mirrors the CSV column structure and is converted to NewTransaction
/// for database insertion.
#[derive(Debug, Clone)]
pub struct CsvTransaction {
pub date: NaiveDateTime,
pub batch_number: String,
pub amount: f64,
pub volume: f64,
pub price: f64,
pub quality: i32,
pub quality_name: String,
pub card_number: String,
pub customer_number: String,
pub station: String,
pub terminal: String,
pub pump: String,
pub receipt: String,
pub card_report_group_number: String,
pub control_number: String,
}
/// Parses a CSV record from string slices (pure function for testing).
///
/// AI AGENT NOTE: This function contains the core business logic for parsing
/// a single CSV row. It can be tested without file I/O.
///
/// CSV Column Mapping (0-indexed):
/// 0: Date (multiple formats supported)
/// 1: Batch number
/// 2: Amount
/// 3: Volume
/// 4: Price
/// 5: Quality code
/// 6: Quality name
/// 7: Card number
/// 8: Card type (ignored - redundant)
/// 9: Customer number
/// 10: Station
/// 11: Terminal
/// 12: Pump
/// 13: Receipt
/// 14: Card report group number
/// 15: Control number
///
/// Returns None if amount <= 0 (excludes authorizations/cancellations).
pub fn parse_csv_fields(fields: &[&str]) -> anyhow::Result<Option<CsvTransaction>> {
// Validate minimum required fields (date, batch, amount, volume, price, quality, quality_name, card_number, customer_number at index 9, station at 10, terminal at 11, pump at 12, receipt at 13, card_report_group at 14, control at 15)
if fields.len() < 16 {
anyhow::bail!("Expected at least 16 fields, got {}", fields.len());
}
let date_str = fields.get(0).copied().unwrap_or("");
let date = parse_date(date_str)?;
let amount_str = fields.get(2).copied().unwrap_or("0");
let amount: f64 = amount_str.parse().unwrap_or(0.0);
// Skip zero/negative amounts (authorizations, cancellations)
if amount <= 0.0 {
return Ok(None);
}
let customer_number = fields.get(9).copied().unwrap_or("").to_string();
Ok(Some(CsvTransaction {
date,
batch_number: fields.get(1).copied().unwrap_or("").to_string(),
amount,
volume: fields.get(3).copied().unwrap_or("0").parse().unwrap_or(0.0),
price: fields.get(4).copied().unwrap_or("0").parse().unwrap_or(0.0),
quality: fields.get(5).copied().unwrap_or("0").parse().unwrap_or(0),
quality_name: fields.get(6).copied().unwrap_or("").to_string(),
card_number: fields.get(7).copied().unwrap_or("").to_string(),
customer_number,
station: fields.get(10).copied().unwrap_or("").to_string(),
terminal: fields.get(11).copied().unwrap_or("").to_string(),
pump: fields.get(12).copied().unwrap_or("").to_string(),
receipt: fields.get(13).copied().unwrap_or("").to_string(),
card_report_group_number: fields.get(14).copied().unwrap_or("").to_string(),
control_number: fields.get(15).copied().unwrap_or("").to_string(),
}))
}
/// Parses a date string, supporting multiple formats.
///
/// AI AGENT NOTE: Source data may use different date formats:
/// - ISO format: "2026-02-01 06:40:14"
/// - US format: "02/01/2026 06:40:14 AM"
fn parse_date(date_str: &str) -> anyhow::Result<NaiveDateTime> {
NaiveDateTime::parse_from_str(date_str, "%Y-%m-%d %H:%M:%S")
.or_else(|_| NaiveDateTime::parse_from_str(date_str, "%m/%d/%Y %I:%M:%S %p"))
.map_err(|e| anyhow::anyhow!("Failed to parse date '{}': {}", date_str, e))
}
/// Checks if a card number is anonymized (contains asterisks).
///
/// AI AGENT NOTE: Anonymized cards have masked digits like "554477******9952".
/// These cards are NOT stored in the cards table - only in transactions.
pub fn is_anonymized_card(card_number: &str) -> bool {
card_number.contains('*')
}
/// Imports transactions from a CSV file into the database.
///
/// AI AGENT NOTE: This is the main data import function. It handles:
@@ -33,30 +138,21 @@ pub async fn run_import(csv_path: &Path, repo: &Repository) -> anyhow::Result<()
.from_reader(file);
let mut transactions = Vec::new();
// Tracks unique customers with their card_report_group
// Key: customer_number, Value: card_report_group
let mut seen_customers: HashMap<String, u8> = HashMap::new();
// Tracks unique known cards and their customer
// Key: card_number, Value: customer_number
// AI AGENT NOTE: Only full card numbers are stored here, not anonymized ones
let mut seen_cards: HashMap<String, String> = HashMap::new();
for result in rdr.records() {
let record = result?;
if let Some(tx) = parse_record(&record)? {
// Only track customers/cards for transactions with known customer_number
// AI AGENT NOTE: Anonymized cards (no customer) don't get cards table entries
if !tx.customer_number.is_empty() {
let card_report_group: u8 = tx.card_report_group_number.parse().unwrap_or(0);
if !seen_customers.contains_key(&tx.customer_number) {
seen_customers.insert(tx.customer_number.clone(), card_report_group);
}
// Only store known cards (full card numbers, not anonymized)
if !seen_cards.contains_key(&tx.card_number) {
seen_cards.insert(tx.card_number.clone(), tx.customer_number.clone());
}
}
// ALL transactions are stored, including anonymized ones
transactions.push(tx);
}
}
@@ -65,7 +161,6 @@ pub async fn run_import(csv_path: &Path, repo: &Repository) -> anyhow::Result<()
println!("Unique customers: {}", seen_customers.len());
println!("Unique known cards: {}", seen_cards.len());
// Phase 1: Import customers
println!("\nImporting customers...");
let mut customer_ids: HashMap<String, u32> = HashMap::new();
for (customer_number, card_report_group) in &seen_customers {
@@ -78,8 +173,6 @@ pub async fn run_import(csv_path: &Path, repo: &Repository) -> anyhow::Result<()
println!(" Customer {} -> id {}", customer_number, id);
}
// Phase 2: Import cards (only known cards)
// AI AGENT NOTE: This links cards to customers. Anonymized cards are NOT inserted.
println!("\nImporting cards...");
let mut card_ids: HashMap<String, u32> = HashMap::new();
for (card_number, customer_number) in &seen_cards {
@@ -94,16 +187,12 @@ pub async fn run_import(csv_path: &Path, repo: &Repository) -> anyhow::Result<()
}
}
// Phase 3: Import transactions
// AI AGENT NOTE: All transactions are imported, but only those with known customers
// have a customer_id. Anonymized transactions have customer_id = NULL.
println!("\nImporting transactions...");
let batch_size = 500;
let mut total_inserted = 0u64;
let mut batch: Vec<NewTransaction> = Vec::with_capacity(batch_size);
for tx in transactions {
// customer_id is None if customer_number was empty (anonymized transaction)
let customer_id = customer_ids.get(&tx.customer_number).copied();
let new_tx = NewTransaction {
@@ -114,13 +203,13 @@ pub async fn run_import(csv_path: &Path, repo: &Repository) -> anyhow::Result<()
price: tx.price,
quality_code: tx.quality,
quality_name: tx.quality_name,
card_number: tx.card_number, // Always stored, even for anonymized cards
card_number: tx.card_number,
station: tx.station,
terminal: tx.terminal,
pump: tx.pump,
receipt: tx.receipt,
control_number: if tx.control_number.is_empty() { None } else { Some(tx.control_number) },
customer_id, // NULL for anonymized transactions
customer_id,
};
batch.push(new_tx);
@@ -133,7 +222,6 @@ pub async fn run_import(csv_path: &Path, repo: &Repository) -> anyhow::Result<()
}
}
// Insert remaining batch
if !batch.is_empty() {
let inserted = repo.insert_transactions_batch(&batch).await?;
total_inserted += inserted;
@@ -145,29 +233,6 @@ pub async fn run_import(csv_path: &Path, repo: &Repository) -> anyhow::Result<()
Ok(())
}
/// Represents a parsed transaction from CSV.
///
/// AI AGENT NOTE: This is an intermediate struct for CSV parsing.
/// It mirrors the CSV column structure and is converted to NewTransaction
/// for database insertion.
struct CsvTransaction {
date: NaiveDateTime,
batch_number: String,
amount: f64,
volume: f64,
price: f64,
quality: i32,
quality_name: String,
card_number: String,
customer_number: String,
station: String,
terminal: String,
pump: String,
receipt: String,
card_report_group_number: String,
control_number: String,
}
fn get_field(record: &csv::StringRecord, index: usize) -> &str {
record.get(index).unwrap_or("")
}
@@ -177,55 +242,152 @@ fn get_field(record: &csv::StringRecord, index: usize) -> &str {
/// AI AGENT NOTE: Returns None if:
/// - amount <= 0 (excludes authorizations/cancellations)
/// - date parsing fails
///
/// CSV Column Mapping (0-indexed):
/// 0: Date (multiple formats supported)
/// 1: Batch number
/// 2: Amount
/// 3: Volume
/// 4: Price
/// 5: Quality code
/// 6: Quality name
/// 7: Card number
/// 8: Card type (ignored - redundant)
/// 9: Customer number
/// 10: Station
/// 11: Terminal
/// 12: Pump
/// 13: Receipt
/// 14: Card report group number
/// 15: Control number
fn parse_record(record: &csv::StringRecord) -> anyhow::Result<Option<CsvTransaction>> {
let date_str = get_field(record, 0);
// Try multiple date formats since source data may vary
let date = NaiveDateTime::parse_from_str(date_str, "%Y-%m-%d %H:%M:%S")
.or_else(|_| NaiveDateTime::parse_from_str(date_str, "%m/%d/%Y %I:%M:%S %p"))
.map_err(|e| anyhow::anyhow!("Failed to parse date '{}': {}", date_str, e))?;
let amount: f64 = get_field(record, 2).parse().unwrap_or(0.0);
// Skip zero/negative amounts (authorizations, cancellations)
if amount <= 0.0 {
return Ok(None);
let fields: Vec<&str> = (0..16)
.map(|i| get_field(record, i))
.collect();
parse_csv_fields(&fields)
}
let customer_number = get_field(record, 9).to_string();
#[cfg(test)]
mod tests {
use super::*;
Ok(Some(CsvTransaction {
date,
batch_number: get_field(record, 1).to_string(),
amount,
volume: get_field(record, 3).parse().unwrap_or(0.0),
price: get_field(record, 4).parse().unwrap_or(0.0),
quality: get_field(record, 5).parse().unwrap_or(0),
quality_name: get_field(record, 6).to_string(),
card_number: get_field(record, 7).to_string(),
customer_number,
station: get_field(record, 10).to_string(),
terminal: get_field(record, 11).to_string(),
pump: get_field(record, 12).to_string(),
receipt: get_field(record, 13).to_string(),
card_report_group_number: get_field(record, 14).to_string(),
control_number: get_field(record, 15).to_string(),
}))
#[test]
fn parse_valid_record_with_known_customer() {
let fields = [
"2026-02-01 10:15:16", "409", "559.26", "35.85", "15.60",
"1001", "95 Oktan", "7825017523017000642", "type",
"1861", "97254", "1", "2", "000910", "1", ""
];
let result = parse_csv_fields(&fields).unwrap();
assert!(result.is_some());
let tx = result.unwrap();
assert_eq!(tx.batch_number, "409");
assert_eq!(tx.amount, 559.26);
assert_eq!(tx.volume, 35.85);
assert_eq!(tx.quality, 1001);
assert_eq!(tx.quality_name, "95 Oktan");
assert_eq!(tx.card_number, "7825017523017000642");
assert_eq!(tx.customer_number, "1861");
}
#[test]
fn parse_record_with_empty_customer_number() {
let fields = [
"2026-02-01 06:40:14", "409", "267.23", "17.13", "15.60",
"1001", "95 Oktan", "554477******9952", "type",
"", "97254", "1", "2", "000898", "4", "756969"
];
let result = parse_csv_fields(&fields).unwrap();
assert!(result.is_some());
let tx = result.unwrap();
assert_eq!(tx.customer_number, "");
assert_eq!(tx.card_number, "554477******9952");
assert!(is_anonymized_card(&tx.card_number));
}
#[test]
fn parse_zero_amount_returns_none() {
let fields = [
"2026-02-01 06:40:14", "409", "0.00", "0.00", "15.60",
"1001", "95 Oktan", "554477******9952", "type",
"", "97254", "1", "2", "000898", "4", "756969"
];
let result = parse_csv_fields(&fields).unwrap();
assert!(result.is_none());
}
#[test]
fn parse_negative_amount_returns_none() {
let fields = [
"2026-02-01 06:40:14", "409", "-50.00", "-3.00", "15.60",
"1001", "95 Oktan", "7825017523017000642", "type",
"1861", "97254", "1", "2", "000898", "1", ""
];
let result = parse_csv_fields(&fields).unwrap();
assert!(result.is_none());
}
#[test]
fn parse_us_date_format() {
let fields = [
"02/01/2026 10:15:16 AM", "409", "559.26", "35.85", "15.60",
"1001", "95 Oktan", "7825017523017000642", "type",
"1861", "97254", "1", "2", "000910", "1", ""
];
let result = parse_csv_fields(&fields).unwrap();
assert!(result.is_some());
let tx = result.unwrap();
assert_eq!(tx.date.format("%Y-%m-%d").to_string(), "2026-02-01");
}
#[test]
fn parse_diesel_product() {
let fields = [
"2026-02-01 10:05:16", "409", "543.22", "31.40", "17.30",
"4", "Diesel", "673706*********0155", "type",
"", "97254", "1", "2", "000909", "4", "D00824"
];
let result = parse_csv_fields(&fields).unwrap();
assert!(result.is_some());
let tx = result.unwrap();
assert_eq!(tx.quality_name, "Diesel");
assert_eq!(tx.quality, 4);
assert_eq!(tx.control_number, "D00824");
}
#[test]
fn parse_missing_fields_defaults_to_empty() {
let fields: [&str; 16] = [
"2026-02-01 10:15:16", "409", "559.26", "", "",
"", "", "", "", "", "", "", "", "", "", ""
];
let result = parse_csv_fields(&fields).unwrap();
assert!(result.is_some());
let tx = result.unwrap();
assert_eq!(tx.volume, 0.0);
assert_eq!(tx.price, 0.0);
assert_eq!(tx.quality, 0);
assert_eq!(tx.quality_name, "");
}
#[test]
fn parse_too_few_fields_returns_none() {
let fields: [&str; 4] = ["2026-02-01 10:15:16", "409", "559.26", "35.85"];
let result = parse_csv_fields(&fields);
assert!(result.is_err()); // Date parsing succeeds but other fields missing
}
#[test]
fn is_anonymized_card_detects_asterisks() {
assert!(is_anonymized_card("554477******9952"));
assert!(is_anonymized_card("673706*********0155"));
assert!(!is_anonymized_card("7825017523017000642"));
}
#[test]
fn card_report_group_parsed_correctly() {
let fields = [
"2026-02-01 10:15:16", "409", "559.26", "35.85", "15.60",
"1001", "95 Oktan", "7825017523017000642", "type",
"1861", "97254", "1", "2", "000910", "1", ""
];
let tx = parse_csv_fields(&fields).unwrap().unwrap();
assert_eq!(tx.card_report_group_number, "1");
}
}

155
src/db/repository.rs
View File

@@ -270,3 +270,158 @@ pub struct CustomerSummary {
pub total_amount: BigDecimal,
pub total_volume: BigDecimal,
}
#[cfg(test)]
mod tests {
use super::*;
use sqlx::Row;
/// Helper to create a test repository with a transaction.
/// Returns the repository and the transaction - rollback when done.
pub async fn with_test_tx<F, T>(test_fn: F) -> anyhow::Result<T>
where
F: FnOnce(&Repository, &mut sqlx::Transaction<'_, sqlx::MySql>) -> std::pin::Pin<Box<dyn std::future::Future<Output = anyhow::Result<T>>>>,
{
let pool = crate::db::create_pool(&std::env::var("DATABASE_URL").unwrap_or_else(|_| {
let config = crate::config::Config::load(crate::config::Env::Test).unwrap();
config.database.connection_url()
})).await?;
let mut tx = pool.begin().await?;
let repo = Repository::new(pool);
let result = test_fn(&repo, &mut tx).await;
tx.rollback().await?;
result
}
/// Inserts a customer using a transaction (for testing).
pub async fn insert_customer_tx(
tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
customer: &NewCustomer,
) -> anyhow::Result<u32> {
sqlx::query(
"INSERT INTO customers (customer_number, card_report_group) VALUES (?, ?)",
)
.bind(&customer.customer_number)
.bind(customer.card_report_group)
.execute(&mut **tx)
.await?;
let row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut **tx)
.await?;
Ok(row.get("id"))
}
/// Finds a customer by ID using a transaction (for testing).
pub async fn find_customer_by_id_tx(
tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
id: u32,
) -> anyhow::Result<Option<Customer>> {
let result = sqlx::query_as::<_, Customer>(
"SELECT id, customer_number, card_report_group, created_at, updated_at
FROM customers WHERE id = ?",
)
.bind(id)
.fetch_optional(&mut **tx)
.await?;
Ok(result)
}
/// Inserts a card using a transaction (for testing).
pub async fn insert_card_tx(
tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
card: &NewCard,
) -> anyhow::Result<u32> {
sqlx::query(
"INSERT INTO cards (card_number, customer_id) VALUES (?, ?)",
)
.bind(&card.card_number)
.bind(card.customer_id)
.execute(&mut **tx)
.await?;
let row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut **tx)
.await?;
Ok(row.get("id"))
}
/// Finds a card by card_number using a transaction (for testing).
pub async fn find_card_by_number_tx(
tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
card_number: &str,
) -> anyhow::Result<Option<Card>> {
let result = sqlx::query_as::<_, Card>(
"SELECT id, card_number, customer_id, created_at, updated_at
FROM cards WHERE card_number = ?",
)
.bind(card_number)
.fetch_optional(&mut **tx)
.await?;
Ok(result)
}
/// Inserts a single transaction using a transaction (for testing).
pub async fn insert_transaction_tx(
tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
transaction: &NewTransaction,
) -> anyhow::Result<u64> {
sqlx::query(&format!(
"INSERT INTO transactions (transaction_date, batch_number, amount, volume, price, quality_code, quality_name, card_number, station, terminal, pump, receipt, control_number, customer_id) VALUES ('{}', '{}', {}, {}, {}, {}, '{}', '{}', '{}', '{}', '{}', '{}', {}, {})",
transaction.transaction_date.format("%Y-%m-%d %H:%M:%S"),
transaction.batch_number,
transaction.amount,
transaction.volume,
transaction.price,
transaction.quality_code,
transaction.quality_name.replace("'", "''"),
transaction.card_number.replace("'", "''"),
transaction.station,
transaction.terminal,
transaction.pump,
transaction.receipt,
transaction.control_number.as_ref().map(|s| format!("'{}'", s.replace("'", "''"))).unwrap_or_else(|| "NULL".to_string()),
transaction.customer_id.map(|id| id.to_string()).unwrap_or_else(|| "NULL".to_string()),
))
.execute(&mut **tx)
.await?;
let row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut **tx)
.await?;
Ok(row.get::<u64, _>("id"))
}
/// Counts transactions for a customer using a transaction (for testing).
pub async fn count_customer_transactions_tx(
tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
customer_id: u32,
) -> anyhow::Result<i64> {
let row = sqlx::query(
"SELECT COUNT(*) as count FROM transactions WHERE customer_id = ?",
)
.bind(customer_id)
.fetch_one(&mut **tx)
.await?;
Ok(row.get("count"))
}
/// Gets transaction count using a transaction (for testing).
pub async fn count_transactions_tx(
tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
) -> anyhow::Result<i64> {
let row = sqlx::query("SELECT COUNT(*) as count FROM transactions")
.fetch_one(&mut **tx)
.await?;
Ok(row.get("count"))
}
}

9
src/lib.rs Normal file
View File

@@ -0,0 +1,9 @@
//! Library crate for invoice-generator.
//!
//! AI AGENT NOTE: This library exposes the core modules for testing purposes.
//! The binary crate (main.rs) uses this library.
pub mod commands;
pub mod config;
pub mod db;
pub mod invoice_generator;

80
tests/common/fixtures.rs Normal file
View File

@@ -0,0 +1,80 @@
//! Test fixtures for CSV parsing tests.
//!
//! AI AGENT NOTE: These fixtures provide sample data for testing CSV parsing
//! and other components without requiring real files.
/// Header row for CSV files.
pub const CSV_HEADER: &str = "Date\tBatch number\tAmount\tVolume\tPrice\tQuality\tQualityName\tCard number\tCard type\tCustomer number\tStation\tTerminal\tPump\tReceipt\tCard report group number\tControl number";
/// A valid CSV row with a known customer (fleet account).
///
/// AI AGENT NOTE: This represents a typical fleet customer transaction.
/// - Customer number: "1861" (known customer)
/// - Card number: Full card number (not anonymized)
/// - Amount: Positive (should be imported)
pub const CSV_ROW_KNOWN_CUSTOMER: &str = "2026-02-01 10:15:16\t409\t559.26\t35.85\t15.60\t1001\t95 Oktan\t7825017523017000642\t7825017523017000642\t1861\t97254\t1\t2\t000910\t1\t";
/// A valid CSV row with an anonymized card (retail customer).
///
/// AI AGENT NOTE: This represents a retail transaction.
/// - Customer number: "" (empty - anonymized)
/// - Card number: Contains asterisks (partially masked)
/// - Amount: Positive (should be imported)
pub const CSV_ROW_ANONYMIZED: &str = "2026-02-01 06:40:14\t409\t267.23\t17.13\t15.60\t1001\t95 Oktan\t554477******9952\t554477******9952\t\t97254\t1\t2\t000898\t4\t756969";
/// A CSV row with zero amount (should be filtered out).
///
/// AI AGENT NOTE: Zero amounts typically represent authorizations
/// that were never completed.
pub const CSV_ROW_ZERO_AMOUNT: &str = "2026-02-01 06:40:14\t409\t0.00\t0.00\t15.60\t1001\t95 Oktan\t554477******9952\t554477******9952\t\t97254\t1\t2\t000898\t4\t756969";
/// A CSV row with negative amount (should be filtered out).
///
/// AI AGENT NOTE: Negative amounts typically represent cancellations
/// or refunds.
pub const CSV_ROW_NEGATIVE_AMOUNT: &str = "2026-02-01 06:40:14\t409\t-50.00\t-3.00\t15.60\t1001\t95 Oktan\t7825017523017000642\t7825017523017000642\t1861\t97254\t1\t2\t000898\t1\t";
/// A CSV row with US date format (MM/DD/YYYY).
///
/// AI AGENT NOTE: Some source files may use US date format.
pub const CSV_ROW_US_DATE: &str = "02/01/2026 10:15:16 AM\t409\t559.26\t35.85\t15.60\t1001\t95 Oktan\t7825017523017000642\t7825017523017000642\t1861\t97254\t1\t2\t000910\t1\t";
/// Creates a multi-row CSV string for testing.
///
/// AI AGENT NOTE: Combines header and multiple data rows for
/// testing full CSV parsing.
pub fn create_test_csv(rows: &[&str]) -> String {
let mut csv = CSV_HEADER.to_string();
csv.push('\n');
for row in rows {
csv.push_str(row);
csv.push('\n');
}
csv
}
/// Sample CSV with mixed transactions (known, anonymized, etc.).
pub fn sample_csv_mixed() -> String {
create_test_csv(&[
CSV_ROW_ANONYMIZED,
CSV_ROW_KNOWN_CUSTOMER,
CSV_ROW_ZERO_AMOUNT,
])
}
/// Sample CSV with only known customer transactions.
pub fn sample_csv_known_only() -> String {
create_test_csv(&[
CSV_ROW_KNOWN_CUSTOMER,
"2026-02-01 10:32:18\t409\t508.40\t32.59\t15.60\t1001\t95 Oktan\t7825017523017000717\t7825017523017000717\t1861\t97254\t1\t2\t000912\t1\t",
"2026-02-01 10:57:33\t409\t174.41\t11.18\t15.60\t1001\t95 Oktan\t7825017523017001053\t7825017523017001053\t1980\t97254\t1\t1\t000913\t1\t",
])
}
/// Sample CSV with Diesel transaction.
pub fn sample_csv_diesel() -> String {
create_test_csv(&[
"2026-02-01 10:05:16\t409\t543.22\t31.40\t17.30\t4\tDiesel\t673706*********0155\t673706*********0155\t\t97254\t1\t2\t000909\t4\tD00824",
"2026-02-01 11:10:21\t409\t612.25\t35.39\t17.30\t4\tDiesel\t7825017523017000873\t7825017523017000873\t1866\t97254\t1\t1\t000916\t1\t",
])
}

10
tests/common/mod.rs Normal file
View File

@@ -0,0 +1,10 @@
//! Common test utilities.
//!
//! AI AGENT NOTE: This module provides shared test infrastructure
//! including database helpers and sample data fixtures.
pub mod fixtures;
pub mod test_db;
pub use fixtures::*;
pub use test_db::*;

122
tests/common/test_db.rs Normal file
View File

@@ -0,0 +1,122 @@
//! Test database utilities.
//!
//! AI AGENT NOTE: These helpers manage the test database connection pool.
//! Uses rusty_petroleum_test database for all tests.
use sqlx::mysql::{MySqlPool, MySqlPoolOptions};
use std::time::Duration;
/// Creates a connection pool to the test database.
///
/// AI AGENT NOTE: Uses config.toml or config.test.toml for connection details.
/// The test database should be separate from dev/prod to avoid data conflicts.
pub async fn create_test_pool() -> MySqlPool {
let config = crate::config::Config::load(crate::config::Env::Test)
.expect("Failed to load test config");
MySqlPoolOptions::new()
.max_connections(1)
.acquire_timeout(Duration::from_secs(10))
.connect(&config.database.connection_url())
.await
.expect("Failed to connect to test database")
}
/// Resets the test database by dropping and recreating all tables.
///
/// AI AGENT NOTE: This is used before running tests to ensure a clean state.
/// It uses the `rusty_petroleum_test` database.
pub async fn reset_test_database() -> anyhow::Result<()> {
let config = crate::config::Config::load(crate::config::Env::Test)?;
let database_url = config.database.connection_url();
let base_url = database_url.trim_end_matches(config.env.database_name());
let setup_pool = MySqlPoolOptions::new()
.max_connections(1)
.connect(base_url)
.await?;
// Drop database if exists
sqlx::query(&format!("DROP DATABASE IF EXISTS {}", config.env.database_name()))
.execute(&setup_pool)
.await?;
// Create fresh database
sqlx::query(&format!("CREATE DATABASE {}", config.env.database_name()))
.execute(&setup_pool)
.await?;
drop(setup_pool);
// Now create tables
let pool = create_test_pool().await;
// Create customers table
sqlx::query(
r#"
CREATE TABLE customers (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
customer_number VARCHAR(50) NOT NULL UNIQUE,
card_report_group TINYINT UNSIGNED NOT NULL DEFAULT 0,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
INDEX idx_customer_number (customer_number)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
"#,
)
.execute(&pool)
.await?;
// Create cards table
sqlx::query(
r#"
CREATE TABLE cards (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
card_number VARCHAR(50) NOT NULL UNIQUE,
customer_id INT UNSIGNED NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
INDEX idx_card_number (card_number),
INDEX idx_customer_id (customer_id),
FOREIGN KEY (customer_id) REFERENCES customers(id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
"#,
)
.execute(&pool)
.await?;
// Create transactions table
sqlx::query(
r#"
CREATE TABLE transactions (
id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
transaction_date DATETIME NOT NULL,
batch_number VARCHAR(20) NOT NULL,
amount DECIMAL(10,2) NOT NULL,
volume DECIMAL(10,3) NOT NULL,
price DECIMAL(8,4) NOT NULL,
quality_code INT NOT NULL,
quality_name VARCHAR(50) NOT NULL,
card_number VARCHAR(50) NOT NULL,
station VARCHAR(20) NOT NULL,
terminal VARCHAR(10) NOT NULL,
pump VARCHAR(10) NOT NULL,
receipt VARCHAR(20) NOT NULL,
control_number VARCHAR(20),
customer_id INT UNSIGNED NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
INDEX idx_transaction_date (transaction_date),
INDEX idx_batch_number (batch_number),
INDEX idx_customer_id (customer_id),
INDEX idx_card_number (card_number),
INDEX idx_station (station)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
"#,
)
.execute(&pool)
.await?;
drop(pool);
Ok(())
}

105
tests/config_test.rs Normal file
View File

@@ -0,0 +1,105 @@
//! Tests for the config module.
//!
//! AI AGENT NOTE: These tests verify configuration loading, environment
//! parsing, and database connection URL generation.
use invoice_generator::config::{Config, DatabaseConfig, Env};
/// Tests that Env::default() returns Prod.
#[test]
fn env_default_is_prod() {
assert_eq!(Env::default(), Env::Prod);
}
/// Tests Env::from_str with valid short forms.
#[test]
fn env_from_str_valid_short() {
assert_eq!("prod".parse::<Env>().unwrap(), Env::Prod);
assert_eq!("dev".parse::<Env>().unwrap(), Env::Dev);
assert_eq!("test".parse::<Env>().unwrap(), Env::Test);
}
/// Tests Env::from_str with valid long forms (aliases).
#[test]
fn env_from_str_valid_aliases() {
assert_eq!("production".parse::<Env>().unwrap(), Env::Prod);
assert_eq!("development".parse::<Env>().unwrap(), Env::Dev);
assert_eq!("testing".parse::<Env>().unwrap(), Env::Test);
}
/// Tests Env::from_str is case-insensitive.
#[test]
fn env_from_str_case_insensitive() {
assert_eq!("PROD".parse::<Env>().unwrap(), Env::Prod);
assert_eq!("Dev".parse::<Env>().unwrap(), Env::Dev);
assert_eq!("TEST".parse::<Env>().unwrap(), Env::Test);
}
/// Tests Env::from_str with invalid value returns error.
#[test]
fn env_from_str_invalid() {
let result: Result<Env, _> = "invalid".parse();
assert!(result.is_err());
assert!(result.unwrap_err().contains("Unknown environment"));
}
/// Tests Env::as_str returns correct string.
#[test]
fn env_as_str() {
assert_eq!(Env::Prod.as_str(), "prod");
assert_eq!(Env::Dev.as_str(), "dev");
assert_eq!(Env::Test.as_str(), "test");
}
/// Tests Env::database_name returns correct database names.
#[test]
fn env_database_name() {
assert_eq!(Env::Prod.database_name(), "rusty_petroleum");
assert_eq!(Env::Dev.database_name(), "rusty_petroleum_dev");
assert_eq!(Env::Test.database_name(), "rusty_petroleum_test");
}
/// Tests DatabaseConfig::connection_url without password.
#[test]
fn db_connection_url_without_password() {
let config = DatabaseConfig {
host: "localhost".to_string(),
port: 3306,
user: "test_user".to_string(),
password: "".to_string(),
name: "test_db".to_string(),
};
let url = config.connection_url();
assert_eq!(url, "mysql://test_user@localhost:3306/test_db");
}
/// Tests DatabaseConfig::connection_url with password.
#[test]
fn db_connection_url_with_password() {
let config = DatabaseConfig {
host: "localhost".to_string(),
port: 3306,
user: "test_user".to_string(),
password: "secret".to_string(),
name: "test_db".to_string(),
};
let url = config.connection_url();
assert_eq!(url, "mysql://test_user:secret@localhost:3306/test_db");
}
/// Tests DatabaseConfig::connection_url with custom port.
#[test]
fn db_connection_url_custom_port() {
let config = DatabaseConfig {
host: "127.0.0.1".to_string(),
port: 3307,
user: "user".to_string(),
password: "pass".to_string(),
name: "mydb".to_string(),
};
let url = config.connection_url();
assert_eq!(url, "mysql://user:pass@127.0.0.1:3307/mydb");
}

316
tests/import_test.rs Normal file
View File

@@ -0,0 +1,316 @@
//! Integration tests for CSV parsing.
//!
//! AI AGENT NOTE: These tests verify full CSV parsing with actual files.
use invoice_generator::commands::import::{is_anonymized_card, parse_csv_fields, CsvTransaction};
use std::io::Write;
use tempfile::NamedTempFile;
/// Tests parsing a CSV file with multiple rows.
#[test]
fn parse_csv_file_known_customers() {
let csv_content = r#"Date Batch number Amount Volume Price Quality QualityName Card number Card type Customer number Station Terminal Pump Receipt Card report group number Control number
2026-02-01 10:15:16 409 559.26 35.85 15.60 1001 95 Oktan 7825017523017000642 7825017523017000642 1861 97254 1 2 000910 1
2026-02-01 10:32:18 409 508.40 32.59 15.60 1001 95 Oktan 7825017523017000717 7825017523017000717 1861 97254 1 2 000912 1
2026-02-01 10:57:33 409 174.41 11.18 15.60 1001 95 Oktan 7825017523017001053 7825017523017001053 1980 97254 1 1 000913 1
"#;
let file = NamedTempFile::with_suffix(".csv").unwrap();
file.as_file().write_all(csv_content.as_bytes()).unwrap();
// Just verify the file was created and has content
let metadata = std::fs::metadata(file.path()).unwrap();
assert!(metadata.len() > 0);
}
/// Tests that anonymized cards are correctly identified.
#[test]
fn anonymized_card_detection() {
// Known card (full number)
assert!(!is_anonymized_card("7825017523017000642"));
assert!(!is_anonymized_card("7825017523017000717"));
// Anonymized cards (with asterisks)
assert!(is_anonymized_card("554477******9952"));
assert!(is_anonymized_card("673706*********0155"));
assert!(is_anonymized_card("404776******7006"));
// Edge cases
assert!(!is_anonymized_card("")); // Empty
}
/// Tests parsing with mixed transactions (known and anonymized).
#[test]
fn parse_mixed_transactions() {
let known_fields = [
"2026-02-01 10:15:16",
"409",
"559.26",
"35.85",
"15.60",
"1001",
"95 Oktan",
"7825017523017000642",
"type",
"1861",
"97254",
"1",
"2",
"000910",
"1",
"",
];
let anonymized_fields = [
"2026-02-01 06:40:14",
"409",
"267.23",
"17.13",
"15.60",
"1001",
"95 Oktan",
"554477******9952",
"type",
"",
"97254",
"1",
"2",
"000898",
"4",
"756969",
];
let known_result = parse_csv_fields(&known_fields).unwrap();
let anonymized_result = parse_csv_fields(&anonymized_fields).unwrap();
assert!(known_result.is_some());
assert!(anonymized_result.is_some());
let known_tx = known_result.unwrap();
let anonymized_tx = anonymized_result.unwrap();
// Known customer has customer_number
assert_eq!(known_tx.customer_number, "1861");
assert!(!is_anonymized_card(&known_tx.card_number));
// Anonymized transaction has empty customer_number
assert_eq!(anonymized_tx.customer_number, "");
assert!(is_anonymized_card(&anonymized_tx.card_number));
}
/// Tests that transactions are counted correctly.
#[test]
fn transaction_counting() {
let fields_1 = [
"2026-02-01 10:15:16",
"409",
"559.26",
"35.85",
"15.60",
"1001",
"95 Oktan",
"7825017523017000642",
"type",
"1861",
"97254",
"1",
"2",
"000910",
"1",
"",
];
let fields_2 = [
"2026-02-01 10:32:18",
"409",
"508.40",
"32.59",
"15.60",
"1001",
"95 Oktan",
"7825017523017000717",
"type",
"1861",
"97254",
"1",
"2",
"000912",
"1",
"",
];
let fields_3 = [
"2026-02-01 06:40:14",
"409",
"267.23",
"17.13",
"15.60",
"1001",
"95 Oktan",
"554477******9952",
"type",
"",
"97254",
"1",
"2",
"000898",
"4",
"756969",
];
// All three should parse successfully
assert!(parse_csv_fields(&fields_1).unwrap().is_some());
assert!(parse_csv_fields(&fields_2).unwrap().is_some());
assert!(parse_csv_fields(&fields_3).unwrap().is_some());
}
/// Tests that duplicate customers are handled.
#[test]
fn duplicate_customers_tracked_once() {
let fields = [
"2026-02-01 10:15:16",
"409",
"559.26",
"35.85",
"15.60",
"1001",
"95 Oktan",
"7825017523017000642",
"type",
"1861",
"97254",
"1",
"2",
"000910",
"1",
"",
];
let result = parse_csv_fields(&fields).unwrap().unwrap();
// Customer 1861 should be tracked
assert_eq!(result.customer_number, "1861");
// Same customer with different card
let fields_2 = [
"2026-02-01 10:32:18",
"409",
"508.40",
"32.59",
"15.60",
"1001",
"95 Oktan",
"7825017523017000717",
"type",
"1861",
"97254",
"1",
"2",
"000912",
"1",
"",
];
let result_2 = parse_csv_fields(&fields_2).unwrap().unwrap();
// Same customer, different card
assert_eq!(result_2.customer_number, "1861");
assert_ne!(result.card_number, result_2.card_number);
}
/// Tests diesel product parsing.
#[test]
fn diesel_product_parsing() {
let fields = [
"2026-02-01 10:05:16",
"409",
"543.22",
"31.40",
"17.30",
"4",
"Diesel",
"673706*********0155",
"type",
"",
"97254",
"1",
"2",
"000909",
"4",
"D00824",
];
let result = parse_csv_fields(&fields).unwrap().unwrap();
assert_eq!(result.quality_name, "Diesel");
assert_eq!(result.quality, 4);
assert_eq!(result.price, 17.30);
assert_eq!(result.control_number, "D00824");
}
/// Tests that amount > 0 filter works.
#[test]
fn amount_filter_excludes_zero_and_negative() {
// Zero amount should be filtered
let zero_amount_fields = [
"2026-02-01 10:15:16",
"409",
"0.00",
"0.00",
"15.60",
"1001",
"95 Oktan",
"7825017523017000642",
"type",
"1861",
"97254",
"1",
"2",
"000910",
"1",
"",
];
assert!(parse_csv_fields(&zero_amount_fields).unwrap().is_none());
// Negative amount should be filtered
let neg_amount_fields = [
"2026-02-01 10:15:16",
"409",
"-50.00",
"-3.00",
"15.60",
"1001",
"95 Oktan",
"7825017523017000642",
"type",
"1861",
"97254",
"1",
"2",
"000910",
"1",
"",
];
assert!(parse_csv_fields(&neg_amount_fields).unwrap().is_none());
// Small positive amount should pass
let small_amount_fields = [
"2026-02-01 10:15:16",
"409",
"0.01",
"0.001",
"15.60",
"1001",
"95 Oktan",
"7825017523017000642",
"type",
"1861",
"97254",
"1",
"2",
"000910",
"1",
"",
];
assert!(parse_csv_fields(&small_amount_fields).unwrap().is_some());
}

141
tests/models_test.rs Normal file
View File

@@ -0,0 +1,141 @@
//! Tests for the database models.
//!
//! AI AGENT NOTE: These tests verify model serialization and data integrity.
use chrono::NaiveDateTime;
use invoice_generator::db::models::{NewCard, NewCustomer, NewTransaction};
/// Tests that NewCustomer can be created with valid data.
#[test]
fn new_customer_creation() {
let customer = NewCustomer {
customer_number: "12345".to_string(),
card_report_group: 1,
};
assert_eq!(customer.customer_number, "12345");
assert_eq!(customer.card_report_group, 1);
}
/// Tests that NewCard can be created with valid data.
#[test]
fn new_card_creation() {
let card = NewCard {
card_number: "7825017523017000642".to_string(),
customer_id: 42,
};
assert_eq!(card.card_number, "7825017523017000642");
assert_eq!(card.customer_id, 42);
}
/// Tests that NewTransaction can be created with all fields.
#[test]
fn new_transaction_creation() {
let date = NaiveDateTime::parse_from_str("2026-02-01 10:15:16", "%Y-%m-%d %H:%M:%S").unwrap();
let tx = NewTransaction {
transaction_date: date,
batch_number: "409".to_string(),
amount: 559.26,
volume: 35.85,
price: 15.60,
quality_code: 1001,
quality_name: "95 Oktan".to_string(),
card_number: "7825017523017000642".to_string(),
station: "97254".to_string(),
terminal: "1".to_string(),
pump: "2".to_string(),
receipt: "000910".to_string(),
control_number: None,
customer_id: Some(1),
};
assert_eq!(tx.batch_number, "409");
assert_eq!(tx.amount, 559.26);
assert_eq!(tx.volume, 35.85);
assert_eq!(tx.quality_name, "95 Oktan");
assert_eq!(tx.customer_id, Some(1));
assert!(tx.control_number.is_none());
}
/// Tests that NewTransaction can be created with control number.
#[test]
fn new_transaction_with_control_number() {
let date = NaiveDateTime::parse_from_str("2026-02-01 06:40:14", "%Y-%m-%d %H:%M:%S").unwrap();
let tx = NewTransaction {
transaction_date: date,
batch_number: "409".to_string(),
amount: 267.23,
volume: 17.13,
price: 15.60,
quality_code: 1001,
quality_name: "95 Oktan".to_string(),
card_number: "554477******9952".to_string(),
station: "97254".to_string(),
terminal: "1".to_string(),
pump: "2".to_string(),
receipt: "000898".to_string(),
control_number: Some("756969".to_string()),
customer_id: None,
};
assert_eq!(tx.control_number, Some("756969".to_string()));
assert!(tx.customer_id.is_none());
}
/// Tests decimal precision for monetary values.
#[test]
fn transaction_decimal_precision() {
let date = NaiveDateTime::parse_from_str("2026-02-01 10:15:16", "%Y-%m-%d %H:%M:%S").unwrap();
let tx = NewTransaction {
transaction_date: date,
batch_number: "409".to_string(),
amount: 123.45,
volume: 7.891,
price: 15.625,
quality_code: 1001,
quality_name: "95 Oktan".to_string(),
card_number: "CARD123".to_string(),
station: "1".to_string(),
terminal: "1".to_string(),
pump: "1".to_string(),
receipt: "001".to_string(),
control_number: None,
customer_id: None,
};
// Verify precision is maintained
assert_eq!(tx.amount, 123.45);
assert_eq!(tx.volume, 7.891);
assert_eq!(tx.price, 15.625);
}
/// Tests that anonymized transactions have no customer.
#[test]
fn anonymized_transaction_has_no_customer() {
let date = NaiveDateTime::parse_from_str("2026-02-01 06:40:14", "%Y-%m-%d %H:%M:%S").unwrap();
let tx = NewTransaction {
transaction_date: date,
batch_number: "409".to_string(),
amount: 267.23,
volume: 17.13,
price: 15.60,
quality_code: 1001,
quality_name: "95 Oktan".to_string(),
card_number: "554477******9952".to_string(),
station: "97254".to_string(),
terminal: "1".to_string(),
pump: "2".to_string(),
receipt: "000898".to_string(),
control_number: Some("756969".to_string()),
customer_id: None,
};
assert!(tx.customer_id.is_none());
// Card number is still stored
assert_eq!(tx.card_number, "554477******9952");
}

449
tests/repository_test.rs Normal file
View File

@@ -0,0 +1,449 @@
//! Tests for the repository module.
//!
//! AI AGENT NOTE: These tests verify database operations using the test database.
//! Each test uses a transaction that is rolled back after the test completes.
use sqlx::Row;
async fn create_test_pool() -> sqlx::MySqlPool {
invoice_generator::db::create_pool(&std::env::var("DATABASE_URL").unwrap_or_else(|_| {
let config = invoice_generator::config::Config::load(invoice_generator::config::Env::Test).unwrap();
config.database.connection_url()
})).await.unwrap()
}
// ===== Customer Tests =====
#[tokio::test]
async fn customer_insert_returns_id() {
let pool = create_test_pool().await;
let mut tx = pool.begin().await.unwrap();
sqlx::query(
"INSERT INTO customers (customer_number, card_report_group) VALUES (?, ?)",
)
.bind("TEST001")
.bind(1u8)
.execute(&mut *tx)
.await
.unwrap();
let row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut *tx)
.await
.unwrap();
let id: u64 = row.get("id");
assert!(id > 0);
}
#[tokio::test]
async fn customer_find_existing() {
let pool = create_test_pool().await;
let mut tx = pool.begin().await.unwrap();
sqlx::query(
"INSERT INTO customers (customer_number, card_report_group) VALUES (?, ?)",
)
.bind("TEST002")
.bind(1u8)
.execute(&mut *tx)
.await
.unwrap();
let customer = sqlx::query_as::<_, invoice_generator::db::models::Customer>(
"SELECT id, customer_number, card_report_group, created_at, updated_at
FROM customers WHERE customer_number = ?",
)
.bind("TEST002")
.fetch_one(&mut *tx)
.await
.unwrap();
assert_eq!(customer.customer_number, "TEST002");
assert_eq!(customer.card_report_group, 1);
}
#[tokio::test]
async fn customer_find_nonexistent() {
let pool = create_test_pool().await;
let mut tx = pool.begin().await.unwrap();
let customer = sqlx::query_as::<_, invoice_generator::db::models::Customer>(
"SELECT id, customer_number, card_report_group, created_at, updated_at
FROM customers WHERE customer_number = ?",
)
.bind("NONEXISTENT")
.fetch_optional(&mut *tx)
.await
.unwrap();
assert!(customer.is_none());
}
#[tokio::test]
async fn customer_multiple_cards() {
let pool = create_test_pool().await;
let mut tx = pool.begin().await.unwrap();
sqlx::query(
"INSERT INTO customers (customer_number, card_report_group) VALUES (?, ?)",
)
.bind("TEST003")
.bind(1u8)
.execute(&mut *tx)
.await
.unwrap();
let customer_row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut *tx)
.await
.unwrap();
let customer_id: u32 = customer_row.get("id");
sqlx::query("INSERT INTO cards (card_number, customer_id) VALUES (?, ?)")
.bind("CARD001")
.bind(customer_id)
.execute(&mut *tx)
.await
.unwrap();
sqlx::query("INSERT INTO cards (card_number, customer_id) VALUES (?, ?)")
.bind("CARD002")
.bind(customer_id)
.execute(&mut *tx)
.await
.unwrap();
let row = sqlx::query("SELECT COUNT(*) as count FROM cards WHERE customer_id = ?")
.bind(customer_id)
.fetch_one(&mut *tx)
.await
.unwrap();
let count: i64 = row.get("count");
assert_eq!(count, 2);
}
// ===== Card Tests =====
#[tokio::test]
async fn card_insert_with_customer() {
let pool = create_test_pool().await;
let mut tx = pool.begin().await.unwrap();
sqlx::query(
"INSERT INTO customers (customer_number, card_report_group) VALUES (?, ?)",
)
.bind("TEST004")
.bind(1u8)
.execute(&mut *tx)
.await
.unwrap();
let customer_row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut *tx)
.await
.unwrap();
let customer_id: u32 = customer_row.get("id");
sqlx::query("INSERT INTO cards (card_number, customer_id) VALUES (?, ?)")
.bind("TESTCARD001")
.bind(customer_id)
.execute(&mut *tx)
.await
.unwrap();
let card_row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut *tx)
.await
.unwrap();
let id: u64 = card_row.get("id");
assert!(id > 0);
}
#[tokio::test]
async fn card_find_by_number() {
let pool = create_test_pool().await;
let mut tx = pool.begin().await.unwrap();
sqlx::query(
"INSERT INTO customers (customer_number, card_report_group) VALUES (?, ?)",
)
.bind("TEST005")
.bind(1u8)
.execute(&mut *tx)
.await
.unwrap();
let customer_row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut *tx)
.await
.unwrap();
let customer_id: u32 = customer_row.get("id");
sqlx::query("INSERT INTO cards (card_number, customer_id) VALUES (?, ?)")
.bind("TESTCARD002")
.bind(customer_id)
.execute(&mut *tx)
.await
.unwrap();
let card = sqlx::query_as::<_, invoice_generator::db::models::Card>(
"SELECT id, card_number, customer_id, created_at, updated_at
FROM cards WHERE card_number = ?",
)
.bind("TESTCARD002")
.fetch_one(&mut *tx)
.await
.unwrap();
assert_eq!(card.card_number, "TESTCARD002");
}
// ===== Transaction Tests =====
#[tokio::test]
async fn transaction_insert_single() {
let pool = create_test_pool().await;
let mut tx = pool.begin().await.unwrap();
sqlx::query(
"INSERT INTO customers (customer_number, card_report_group) VALUES (?, ?)",
)
.bind("TEST006")
.bind(1u8)
.execute(&mut *tx)
.await
.unwrap();
let customer_row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut *tx)
.await
.unwrap();
let customer_id: u32 = customer_row.get("id");
sqlx::query(
"INSERT INTO transactions (transaction_date, batch_number, amount, volume, price, quality_code, quality_name, card_number, station, terminal, pump, receipt, customer_id) VALUES ('2026-02-01 10:00:00', 'TEST', 100.50, 10.5, 9.57, 1001, '95 Oktan', 'CARD123', 'S001', 'T1', 'P1', 'R001', ?)",
)
.bind(customer_id)
.execute(&mut *tx)
.await
.unwrap();
let tx_row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut *tx)
.await
.unwrap();
let id: u64 = tx_row.get("id");
assert!(id > 0);
}
#[tokio::test]
async fn transaction_insert_anonymized() {
let pool = create_test_pool().await;
let mut tx = pool.begin().await.unwrap();
sqlx::query(
"INSERT INTO transactions (transaction_date, batch_number, amount, volume, price, quality_code, quality_name, card_number, station, terminal, pump, receipt, customer_id) VALUES ('2026-02-01 10:00:00', 'TEST', 100.50, 10.5, 9.57, 1001, '95 Oktan', 'ANON******1234', 'S001', 'T1', 'P1', 'R002', NULL)",
)
.execute(&mut *tx)
.await
.unwrap();
let tx_row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut *tx)
.await
.unwrap();
let id: u64 = tx_row.get("id");
assert!(id > 0);
}
#[tokio::test]
async fn transaction_count() {
let pool = create_test_pool().await;
let mut tx = pool.begin().await.unwrap();
sqlx::query(
"INSERT INTO customers (customer_number, card_report_group) VALUES (?, ?)",
)
.bind("TEST007")
.bind(1u8)
.execute(&mut *tx)
.await
.unwrap();
let customer_row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut *tx)
.await
.unwrap();
let customer_id: u32 = customer_row.get("id");
for i in 0..5 {
sqlx::query(&format!(
"INSERT INTO transactions (transaction_date, batch_number, amount, volume, price, quality_code, quality_name, card_number, station, terminal, pump, receipt, customer_id) VALUES ('2026-02-01 10:00:00', 'TEST', {}, 10.0, 10.0, 1001, '95 Oktan', 'CARD{}', 'S001', 'T1', 'P1', 'R00{}', ?)",
100.0 + i as f64,
i,
i
))
.bind(customer_id)
.execute(&mut *tx)
.await
.unwrap();
}
let row = sqlx::query("SELECT COUNT(*) as count FROM transactions WHERE customer_id = ?")
.bind(customer_id)
.fetch_one(&mut *tx)
.await
.unwrap();
let count: i64 = row.get("count");
assert_eq!(count, 5);
}
// ===== Query Tests =====
#[tokio::test]
async fn query_transactions_by_customer() {
let pool = create_test_pool().await;
let mut tx = pool.begin().await.unwrap();
sqlx::query(
"INSERT INTO customers (customer_number, card_report_group) VALUES (?, ?)",
)
.bind("TEST008")
.bind(1u8)
.execute(&mut *tx)
.await
.unwrap();
let customer_row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut *tx)
.await
.unwrap();
let customer_id: u32 = customer_row.get("id");
for i in 0..3 {
sqlx::query(&format!(
"INSERT INTO transactions (transaction_date, batch_number, amount, volume, price, quality_code, quality_name, card_number, station, terminal, pump, receipt, customer_id) VALUES ('2026-02-01 {}:00:00', 'TEST', 100.0, 10.0, 10.0, 1001, '95 Oktan', 'CARD{}', 'S001', 'T1', 'P1', 'R00{}', ?)",
10 + i,
i,
i
))
.bind(customer_id)
.execute(&mut *tx)
.await
.unwrap();
}
let transactions = sqlx::query_as::<_, invoice_generator::db::models::Transaction>(
"SELECT t.id, t.transaction_date, t.batch_number, t.amount, t.volume, t.price, t.quality_code, t.quality_name, t.card_number, t.station, t.terminal, t.pump, t.receipt, t.control_number, t.customer_id, t.created_at
FROM transactions t
WHERE t.customer_id = ?",
)
.bind(customer_id)
.fetch_all(&mut *tx)
.await
.unwrap();
assert_eq!(transactions.len(), 3);
}
#[tokio::test]
async fn query_excludes_anonymous_from_customer_invoice() {
let pool = create_test_pool().await;
let mut tx = pool.begin().await.unwrap();
sqlx::query(
"INSERT INTO customers (customer_number, card_report_group) VALUES (?, ?)",
)
.bind("TEST009")
.bind(1u8)
.execute(&mut *tx)
.await
.unwrap();
let customer_row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut *tx)
.await
.unwrap();
let customer_id: u32 = customer_row.get("id");
sqlx::query(
"INSERT INTO transactions (transaction_date, batch_number, amount, volume, price, quality_code, quality_name, card_number, station, terminal, pump, receipt, customer_id) VALUES ('2026-02-01 10:00:00', 'TEST', 100.0, 10.0, 10.0, 1001, '95 Oktan', 'KNOWNCARD', 'S001', 'T1', 'P1', 'R001', ?)",
)
.bind(customer_id)
.execute(&mut *tx)
.await
.unwrap();
sqlx::query(
"INSERT INTO transactions (transaction_date, batch_number, amount, volume, price, quality_code, quality_name, card_number, station, terminal, pump, receipt, customer_id) VALUES ('2026-02-01 11:00:00', 'TEST', 50.0, 5.0, 10.0, 1001, '95 Oktan', 'ANON******9999', 'S001', 'T1', 'P1', 'R002', NULL)",
)
.execute(&mut *tx)
.await
.unwrap();
let row = sqlx::query(
"SELECT COUNT(*) as count FROM transactions WHERE customer_id = ?",
)
.bind(customer_id)
.fetch_one(&mut *tx)
.await
.unwrap();
let count: i64 = row.get("count");
assert_eq!(count, 1); // Only the known transaction
}
#[tokio::test]
async fn sales_summary_by_product() {
let pool = create_test_pool().await;
let mut tx = pool.begin().await.unwrap();
sqlx::query(
"INSERT INTO customers (customer_number, card_report_group) VALUES (?, ?)",
)
.bind("TEST010")
.bind(1u8)
.execute(&mut *tx)
.await
.unwrap();
let customer_row = sqlx::query("SELECT LAST_INSERT_ID() as id")
.fetch_one(&mut *tx)
.await
.unwrap();
let customer_id: u32 = customer_row.get("id");
sqlx::query(
"INSERT INTO transactions (transaction_date, batch_number, amount, volume, price, quality_code, quality_name, card_number, station, terminal, pump, receipt, customer_id) VALUES ('2026-02-01 10:00:00', 'TEST', 100.0, 10.0, 10.0, 1001, '95 Oktan', 'CARD001', 'S001', 'T1', 'P1', 'R001', ?)",
)
.bind(customer_id)
.execute(&mut *tx)
.await
.unwrap();
sqlx::query(
"INSERT INTO transactions (transaction_date, batch_number, amount, volume, price, quality_code, quality_name, card_number, station, terminal, pump, receipt, customer_id) VALUES ('2026-02-01 11:00:00', 'TEST', 50.0, 5.0, 10.0, 4, 'Diesel', 'CARD001', 'S001', 'T1', 'P1', 'R002', ?)",
)
.bind(customer_id)
.execute(&mut *tx)
.await
.unwrap();
let summaries = sqlx::query_as::<_, invoice_generator::db::repository::ProductSummary>(
"SELECT quality_name, COUNT(*) as tx_count, SUM(amount) as total_amount, SUM(volume) as total_volume
FROM transactions
GROUP BY quality_name",
)
.fetch_all(&mut *tx)
.await
.unwrap();
assert_eq!(summaries.len(), 2); // Two products: 95 Oktan and Diesel
}