Lines
91.57 %
Functions
21.67 %
Branches
100 %
use finance::{commodity::Commodity, tag::Tag};
use num_rational::Rational64;
use sqlx::types::Uuid;
use std::{collections::HashMap, fmt::Debug};
use supp_macro::command;
use super::{CmdError, CmdResult};
use crate::{command::FinanceEntity, config::ConfigError, user::User};
command! {
GetCommodity {
#[required]
user_id: Uuid,
commodity_id: Uuid,
} => {
let user = User { id: user_id };
let mut conn = user.get_connection().await.map_err(|err| {
log::error!("{}", t!("Database error: %{err}", err = err : {:?}));
ConfigError::DB
})?;
let comm = sqlx::query_file_as!(Commodity, "sql/select/commodities/by_id.sql", &commodity_id)
.fetch_one(&mut *conn)
.await?;
// For each commodity, get its tags
let mut tagged_entities = Vec::new();
let tags: HashMap<String, FinanceEntity> =
sqlx::query_file!("sql/select/tags/by_commodity.sql", &commodity_id)
.fetch_all(&mut *conn)
.await?
.into_iter()
.map(|row| {
(
row.tag_name.clone(),
FinanceEntity::Tag(Tag {
id: row.id,
tag_name: row.tag_name,
tag_value: row.tag_value,
description: row.description,
}),
)
})
.collect();
tagged_entities.push((FinanceEntity::Commodity(comm), tags));
Ok(Some(CmdResult::TaggedEntities {
entities: tagged_entities,
pagination: None,
}))
}
CreateCommodity {
symbol: String,
name: String,
Ok(Some(
user.create_commodity(symbol, name)
.id
.to_string()
.into(),
))
ListCommodities {
// Get all commodities
let commodities: Vec<Commodity> = sqlx::query_file!("sql/select/commodities/all.sql")
.map(|row| Commodity { id: row.id })
for commodity in commodities {
sqlx::query_file!("sql/select/tags/by_commodity.sql", &commodity.id)
tagged_entities.push((FinanceEntity::Commodity(commodity), tags));
/// Multiplies two rationals through i128 widening, reduces the i128 product
/// by its gcd, and verifies both parts fit back in i64. Returns `None` on
/// overflow so the caller surfaces a clean error instead of panicking
/// (debug) or wrapping (release). Both operands carry a positive denominator
/// (callers validate), so the product denominator stays positive.
fn checked_ratio_mul(a: Rational64, b: Rational64) -> Option<Rational64> {
fn gcd_i128(mut x: i128, mut y: i128) -> i128 {
while y != 0 {
(x, y) = (y, x % y);
x.abs()
let num = i128::from(*a.numer()) * i128::from(*b.numer());
let den = i128::from(*a.denom()) * i128::from(*b.denom());
let g = gcd_i128(num, den).max(1);
let num = i64::try_from(num / g).ok()?;
let den = i64::try_from(den / g).ok()?;
Some(Rational64::new(num, den))
// Converts a source-commodity amount into a target-commodity amount
// using the most recent Price row that links the two. Looks up the
// direct `source -> target` row first; on miss, tries the inverse
// `target -> source` row and inverts the ratio.
ConvertCommodity {
amount_num: i64,
amount_denom: i64,
source_commodity_id: Uuid,
target_commodity_id: Uuid,
if amount_denom == 0 {
return Err(CmdError::Args(
"convert-commodity: amount has zero denominator".to_string(),
));
let amount = Rational64::new(amount_num, amount_denom);
if source_commodity_id == target_commodity_id {
return Ok(Some(CmdResult::Rational(amount)));
if let Some(row) = sqlx::query_file!(
"sql/select/prices/latest_between.sql",
&source_commodity_id,
&target_commodity_id,
.fetch_optional(&mut *conn)
.await? {
if row.value_denom == 0 {
"convert-commodity: price has zero denominator".to_string(),
let price = Rational64::new(row.value_num, row.value_denom);
let converted = checked_ratio_mul(amount, price).ok_or_else(|| {
CmdError::Args("convert-commodity: conversion overflow".to_string())
return Ok(Some(CmdResult::Rational(converted)));
if row.value_num == 0 {
"convert-commodity: inverse price has zero numerator".to_string(),
let inverse = Rational64::new(row.value_denom, row.value_num);
let converted = checked_ratio_mul(amount, inverse).ok_or_else(|| {
Err(CmdError::Args(format!(
"convert-commodity: no Price row between {source_commodity_id} and {target_commodity_id}"
)))
#[cfg(test)]
mod command_tests {
use super::*;
use crate::db::DB_POOL;
use sqlx::PgPool;
use supp_macro::local_db_sqlx_test;
use tokio::sync::OnceCell;
/// Context for keeping environment intact
static CONTEXT: OnceCell<()> = OnceCell::const_new();
static USER: OnceCell<User> = OnceCell::const_new();
async fn setup() {
CONTEXT
.get_or_init(|| async {
#[cfg(feature = "testlog")]
let _ = env_logger::builder()
.is_test(true)
.filter_level(log::LevelFilter::Trace)
.try_init();
.await;
USER.get_or_init(|| async { User { id: Uuid::new_v4() } })
#[test]
fn checked_ratio_mul_normal_case_reduces() {
let got = checked_ratio_mul(Rational64::new(100, 1), Rational64::new(9, 10));
assert_eq!(got, Some(Rational64::new(90, 1)));
fn checked_ratio_mul_overflow_returns_none() {
let huge = Rational64::new(i64::MAX, 1);
assert_eq!(checked_ratio_mul(huge, Rational64::new(i64::MAX, 1)), None);
fn checked_ratio_mul_zero_numerator_is_zero() {
let got = checked_ratio_mul(Rational64::new(0, 1), Rational64::new(7, 3));
assert_eq!(got, Some(Rational64::new(0, 1)));
#[local_db_sqlx_test]
async fn test_list_commodities_empty(pool: PgPool) -> anyhow::Result<()> {
let user = USER.get().unwrap();
user.commit()
.await
.expect("Failed to commit user to database");
if let Some(CmdResult::TaggedEntities { entities, .. }) =
ListCommodities::new().user_id(user.id).run().await?
{
assert!(
entities.is_empty(),
"Expected no commodities in empty database"
);
} else {
panic!("Expected TaggedEntities result");
async fn test_list_commodities_with_data(pool: PgPool) -> anyhow::Result<()> {
// Create a test commodity with tags
CreateCommodity::new()
.symbol("TST".to_string())
.name("Test Commodity".to_string())
.user_id(user.id)
.run()
// List commodities
assert_eq!(entities.len(), 1, "Expected one commodity");
let (entity, tags) = &entities[0];
if let FinanceEntity::Commodity(_c) = entity {
// Check tags
assert_eq!(tags.len(), 2); // symbol and name tags
for tag in tags.values() {
if let FinanceEntity::Tag(t) = tag {
match t.tag_name.as_str() {
"symbol" => assert_eq!(t.tag_value, "TST"),
"name" => assert_eq!(t.tag_value, "Test Commodity"),
_ => panic!("Unexpected tag: {}", t.tag_name),
panic!("Expected Commodity entity");
async fn test_get_commodity(pool: PgPool) -> anyhow::Result<()> {
// First create a commodity
let commodity_result = CreateCommodity::new()
// Get the commodity ID
let commodity_id = if let Some(CmdResult::String(id)) = commodity_result {
uuid::Uuid::parse_str(&id)?
panic!("Expected commodity ID string result");
};
// Test GetCommodity command
if let Some(CmdResult::TaggedEntities { entities, .. }) = GetCommodity::new()
.commodity_id(commodity_id)
if let FinanceEntity::Commodity(c) = entity {
assert_eq!(c.id, commodity_id);
// Test with non-existent commodity ID
let result = GetCommodity::new()
.commodity_id(Uuid::new_v4())
assert!(result.is_err(), "Expected error for non-existent commodity");