use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Credits {
pub id: crate::domain::id::Id,
pub team_id: crate::domain::id::Id,
balance: i64,
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
}
impl Credits {
pub fn new(
id: crate::domain::id::Id,
team_id: crate::domain::id::Id,
initial_balance: i64,
) -> Self {
let now = Utc::now();
Self {
id,
team_id,
balance: initial_balance,
created_at: now,
updated_at: now,
}
}
pub fn with_timestamps(
id: crate::domain::id::Id,
team_id: crate::domain::id::Id,
balance: i64,
created_at: DateTime<Utc>,
updated_at: DateTime<Utc>,
) -> Self {
Self {
id,
team_id,
balance,
created_at,
updated_at,
}
}
pub fn balance(&self) -> i64 {
self.balance
}
pub fn has_sufficient_balance(&self, amount: i64) -> bool {
self.balance >= amount
}
pub fn deduct(&mut self, amount: i64) -> Result<(), CreditsError> {
if self.balance < amount {
return Err(CreditsError::InsufficientBalance {
current: self.balance,
requested: amount,
});
}
self.balance -= amount;
self.updated_at = Utc::now();
Ok(())
}
pub fn add(&mut self, amount: i64) {
self.balance += amount;
self.updated_at = Utc::now();
}
pub fn set_balance(&mut self, new_balance: i64) {
self.balance = new_balance;
self.updated_at = Utc::now();
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CreditsTransaction {
pub id: crate::domain::id::Id,
pub team_id: crate::domain::id::Id,
pub amount: i64,
pub transaction_type: CreditsTransactionType,
pub description: String,
pub reference_id: Option<crate::domain::id::Id>,
pub created_at: DateTime<Utc>,
}
impl CreditsTransaction {
pub fn new(
id: crate::domain::id::Id,
team_id: crate::domain::id::Id,
amount: i64,
transaction_type: CreditsTransactionType,
description: String,
reference_id: Option<crate::domain::id::Id>,
) -> Self {
Self {
id,
team_id,
amount,
transaction_type,
description,
reference_id,
created_at: Utc::now(),
}
}
pub fn with_timestamp(
id: crate::domain::id::Id,
team_id: crate::domain::id::Id,
amount: i64,
transaction_type: CreditsTransactionType,
description: String,
reference_id: Option<crate::domain::id::Id>,
created_at: DateTime<Utc>,
) -> Self {
Self {
id,
team_id,
amount,
transaction_type,
description,
reference_id,
created_at,
}
}
pub fn is_deduction(&self) -> bool {
self.amount < 0
}
pub fn is_addition(&self) -> bool {
self.amount > 0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CreditsTransactionType {
Search,
Scrape,
Extract,
Crawl,
ManualAdjustment,
Subscription,
Refund,
}
impl std::fmt::Display for CreditsTransactionType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
CreditsTransactionType::Search => write!(f, "search"),
CreditsTransactionType::Scrape => write!(f, "scrape"),
CreditsTransactionType::Extract => write!(f, "extract"),
CreditsTransactionType::Crawl => write!(f, "crawl"),
CreditsTransactionType::ManualAdjustment => write!(f, "manual_adjustment"),
CreditsTransactionType::Subscription => write!(f, "subscription"),
CreditsTransactionType::Refund => write!(f, "refund"),
}
}
}
impl std::str::FromStr for CreditsTransactionType {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"search" => Ok(CreditsTransactionType::Search),
"scrape" => Ok(CreditsTransactionType::Scrape),
"extract" => Ok(CreditsTransactionType::Extract),
"crawl" => Ok(CreditsTransactionType::Crawl),
"manual_adjustment" => Ok(CreditsTransactionType::ManualAdjustment),
"subscription" => Ok(CreditsTransactionType::Subscription),
"refund" => Ok(CreditsTransactionType::Refund),
_ => Err(format!("Invalid transaction type: {}", s)),
}
}
}
#[derive(Debug, thiserror::Error)]
pub enum CreditsError {
#[error("Insufficient balance: have {current}, need {requested}")]
InsufficientBalance { current: i64, requested: i64 },
#[error("Invalid amount: {0}")]
InvalidAmount(String),
#[error("Database error: {0}")]
DatabaseError(String),
}
#[cfg(test)]
mod tests {
use super::*;
use std::str::FromStr;
#[test]
fn test_credits_new_sets_balance_and_timestamps() {
let id = crate::domain::id::Id::generate();
let team_id = crate::domain::id::Id::generate();
let before = Utc::now();
let credits = Credits::new(id, team_id, 1000);
let after = Utc::now();
assert_eq!(credits.id, id);
assert_eq!(credits.team_id, team_id);
assert_eq!(
credits.balance(),
1000,
"balance should match initial_balance"
);
assert!(
credits.created_at >= before && credits.created_at <= after,
"created_at should be now"
);
assert_eq!(credits.created_at, credits.updated_at);
}
#[test]
fn test_credits_new_zero_balance() {
let credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
0,
);
assert_eq!(credits.balance(), 0);
}
#[test]
fn test_credits_new_negative_balance() {
let credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
-50,
);
assert_eq!(credits.balance(), -50, "negative initial balance allowed");
}
#[test]
fn test_credits_with_timestamps_preserves_values() {
let id = crate::domain::id::Id::generate();
let team_id = crate::domain::id::Id::generate();
let created = Utc::now();
let updated = created + chrono::Duration::seconds(60);
let credits = Credits::with_timestamps(id, team_id, 500, created, updated);
assert_eq!(credits.id, id);
assert_eq!(credits.team_id, team_id);
assert_eq!(credits.balance(), 500);
assert_eq!(credits.created_at, created);
assert_eq!(credits.updated_at, updated);
}
#[test]
fn test_has_sufficient_balance_true_when_enough() {
let credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
1000,
);
assert!(
credits.has_sufficient_balance(1000),
"exact amount should be sufficient"
);
assert!(
credits.has_sufficient_balance(500),
"less than balance is sufficient"
);
}
#[test]
fn test_has_sufficient_balance_false_when_insufficient() {
let credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
100,
);
assert!(
!credits.has_sufficient_balance(101),
"more than balance is insufficient"
);
}
#[test]
fn test_has_sufficient_balance_zero_amount_always_true() {
let credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
0,
);
assert!(
credits.has_sufficient_balance(0),
"zero amount against zero balance is sufficient"
);
}
#[test]
fn test_deduct_success_reduces_balance() {
let mut credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
1000,
);
let before = Utc::now();
credits
.deduct(300)
.expect("deduct should succeed with sufficient balance");
assert_eq!(
credits.balance(),
700,
"balance should be reduced by deducted amount"
);
assert!(credits.updated_at >= before, "updated_at should advance");
}
#[test]
fn test_deduct_exact_balance_succeeds() {
let mut credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
500,
);
credits
.deduct(500)
.expect("deducting exact balance should succeed");
assert_eq!(
credits.balance(),
0,
"balance should be 0 after full deduction"
);
}
#[test]
fn test_deduct_insufficient_balance_returns_error() {
let mut credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
100,
);
let err = credits
.deduct(300)
.expect_err("should error when insufficient balance");
match err {
CreditsError::InsufficientBalance { current, requested } => {
assert_eq!(current, 100, "error should report current balance");
assert_eq!(requested, 300, "error should report requested amount");
}
other => panic!("expected InsufficientBalance, got {:?}", other),
}
assert_eq!(
credits.balance(),
100,
"balance should be unchanged on error"
);
}
#[test]
fn test_deduct_zero_amount_succeeds() {
let mut credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
100,
);
credits.deduct(0).expect("deducting 0 should succeed");
assert_eq!(
credits.balance(),
100,
"balance unchanged after deducting 0"
);
}
#[test]
fn test_add_increases_balance() {
let mut credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
500,
);
let before = Utc::now();
credits.add(300);
assert_eq!(
credits.balance(),
800,
"balance should increase by added amount"
);
assert!(credits.updated_at >= before);
}
#[test]
fn test_add_zero_unchanged_but_updates_timestamp() {
let mut credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
500,
);
let old_updated = credits.updated_at;
std::thread::sleep(std::time::Duration::from_millis(2));
credits.add(0);
assert_eq!(credits.balance(), 500);
assert!(
credits.updated_at > old_updated,
"updated_at should advance even for add(0)"
);
}
#[test]
fn test_set_balance_overrides() {
let mut credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
1000,
);
credits.set_balance(42);
assert_eq!(credits.balance(), 42, "set_balance should override");
}
#[test]
fn test_set_balance_negative_allowed() {
let mut credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
100,
);
credits.set_balance(-10);
assert_eq!(
credits.balance(),
-10,
"negative balance allowed via set_balance"
);
}
#[test]
fn test_credits_transaction_new_sets_fields() {
let id = crate::domain::id::Id::generate();
let team_id = crate::domain::id::Id::generate();
let ref_id = crate::domain::id::Id::generate();
let before = Utc::now();
let txn = CreditsTransaction::new(
id,
team_id,
-50,
CreditsTransactionType::Scrape,
"scrape cost".to_string(),
Some(ref_id),
);
let after = Utc::now();
assert_eq!(txn.id, id);
assert_eq!(txn.team_id, team_id);
assert_eq!(txn.amount, -50);
assert_eq!(txn.transaction_type, CreditsTransactionType::Scrape);
assert_eq!(txn.description, "scrape cost");
assert_eq!(txn.reference_id, Some(ref_id));
assert!(
txn.created_at >= before && txn.created_at <= after,
"created_at should be now"
);
}
#[test]
fn test_credits_transaction_new_without_reference() {
let txn = CreditsTransaction::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
100,
CreditsTransactionType::Subscription,
"monthly".to_string(),
None,
);
assert!(txn.reference_id.is_none());
}
#[test]
fn test_credits_transaction_with_timestamp_preserves_ts() {
let id = crate::domain::id::Id::generate();
let team_id = crate::domain::id::Id::generate();
let ts = Utc::now();
let txn = CreditsTransaction::with_timestamp(
id,
team_id,
25,
CreditsTransactionType::Refund,
"refund".to_string(),
None,
ts,
);
assert_eq!(txn.id, id);
assert_eq!(txn.team_id, team_id);
assert_eq!(txn.amount, 25);
assert_eq!(txn.transaction_type, CreditsTransactionType::Refund);
assert_eq!(
txn.created_at, ts,
"with_timestamp should preserve custom ts"
);
}
#[test]
fn test_is_deduction_true_for_negative_amount() {
let txn = CreditsTransaction::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
-10,
CreditsTransactionType::Scrape,
"deduct".to_string(),
None,
);
assert!(txn.is_deduction(), "negative amount is a deduction");
assert!(!txn.is_addition(), "negative amount is not an addition");
}
#[test]
fn test_is_addition_true_for_positive_amount() {
let txn = CreditsTransaction::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
50,
CreditsTransactionType::Subscription,
"add".to_string(),
None,
);
assert!(txn.is_addition(), "positive amount is an addition");
assert!(!txn.is_deduction(), "positive amount is not a deduction");
}
#[test]
fn test_is_deduction_and_is_addition_false_for_zero() {
let txn = CreditsTransaction::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
0,
CreditsTransactionType::ManualAdjustment,
"zero".to_string(),
None,
);
assert!(!txn.is_deduction(), "zero amount is not a deduction");
assert!(!txn.is_addition(), "zero amount is not an addition");
}
#[test]
fn test_transaction_type_display_all_variants() {
assert_eq!(CreditsTransactionType::Search.to_string(), "search");
assert_eq!(CreditsTransactionType::Scrape.to_string(), "scrape");
assert_eq!(CreditsTransactionType::Extract.to_string(), "extract");
assert_eq!(CreditsTransactionType::Crawl.to_string(), "crawl");
assert_eq!(
CreditsTransactionType::ManualAdjustment.to_string(),
"manual_adjustment"
);
assert_eq!(
CreditsTransactionType::Subscription.to_string(),
"subscription"
);
assert_eq!(CreditsTransactionType::Refund.to_string(), "refund");
}
#[test]
fn test_transaction_type_from_str_valid() {
assert_eq!(
CreditsTransactionType::from_str("search").expect("valid"),
CreditsTransactionType::Search
);
assert_eq!(
CreditsTransactionType::from_str("scrape").expect("valid"),
CreditsTransactionType::Scrape
);
assert_eq!(
CreditsTransactionType::from_str("extract").expect("valid"),
CreditsTransactionType::Extract
);
assert_eq!(
CreditsTransactionType::from_str("crawl").expect("valid"),
CreditsTransactionType::Crawl
);
assert_eq!(
CreditsTransactionType::from_str("manual_adjustment").expect("valid"),
CreditsTransactionType::ManualAdjustment
);
assert_eq!(
CreditsTransactionType::from_str("subscription").expect("valid"),
CreditsTransactionType::Subscription
);
assert_eq!(
CreditsTransactionType::from_str("refund").expect("valid"),
CreditsTransactionType::Refund
);
}
#[test]
fn test_transaction_type_from_str_invalid_returns_error() {
let err = CreditsTransactionType::from_str("unknown_type")
.expect_err("invalid type should error");
assert!(
err.contains("Invalid transaction type"),
"error should describe invalid type: {}",
err
);
assert!(
err.contains("unknown_type"),
"error should include the bad value"
);
}
#[test]
fn test_transaction_type_serde_roundtrip() {
for ty in [
CreditsTransactionType::Search,
CreditsTransactionType::Scrape,
CreditsTransactionType::Extract,
CreditsTransactionType::Crawl,
CreditsTransactionType::ManualAdjustment,
CreditsTransactionType::Subscription,
CreditsTransactionType::Refund,
] {
let json = serde_json::to_string(&ty).expect("serialize");
let back: CreditsTransactionType = serde_json::from_str(&json).expect("deserialize");
assert_eq!(ty, back, "roundtrip should preserve: {}", json);
}
}
#[test]
fn test_credits_error_insufficient_balance_display() {
let err = CreditsError::InsufficientBalance {
current: 50,
requested: 100,
};
let msg = err.to_string();
assert!(msg.contains("Insufficient balance"), "msg: {}", msg);
assert!(msg.contains("50"), "should show current: {}", msg);
assert!(msg.contains("100"), "should show requested: {}", msg);
}
#[test]
fn test_credits_error_invalid_amount_display() {
let err = CreditsError::InvalidAmount("negative".to_string());
assert!(err.to_string().contains("Invalid amount"));
assert!(err.to_string().contains("negative"));
}
#[test]
fn test_credits_error_database_error_display() {
let err = CreditsError::DatabaseError("conn lost".to_string());
assert!(err.to_string().contains("Database error"));
assert!(err.to_string().contains("conn lost"));
}
#[test]
fn test_credits_serde_roundtrip() {
let credits = Credits::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
750,
);
let json = serde_json::to_string(&credits).expect("serialize");
let back: Credits = serde_json::from_str(&json).expect("deserialize");
assert_eq!(credits, back, "serde roundtrip should preserve credits");
}
#[test]
fn test_credits_transaction_serde_roundtrip() {
let txn = CreditsTransaction::new(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
-25,
CreditsTransactionType::Crawl,
"crawl cost".to_string(),
Some(crate::domain::id::Id::generate()),
);
let json = serde_json::to_string(&txn).expect("serialize");
let back: CreditsTransaction = serde_json::from_str(&json).expect("deserialize");
assert_eq!(txn, back, "serde roundtrip should preserve transaction");
}
}