Grcov report - unit

1

use chrono::NaiveDate;

2

use finance::error::ReportError;

3

use num_rational::Rational64;

4

use sqlx::types::Uuid;

5

6

use super::super::{BreakdownSort, FilterEntity, PeriodGrouping, ReportFilter};

7

use super::filter::SqlParam;

8

use super::period::{

9

    boundaries, check_range, generate_month_boundaries, generate_quarter_boundaries,

10

    generate_year_boundaries,

11

};

12

use super::tree::{

13

    AccountAmounts, AccountRow, ConversionTarget, accumulate_split_converted, build_tree,

14

};

15

16

#[test]

17

1

fn test_to_sql_account_eq() {

18

1

    let id = Uuid::new_v4();

19

1

    let filter = ReportFilter::AccountEq(id);

20

1

    let mut offset = 0;

21

1

    let (sql, params) = filter.to_sql(&mut offset);

22

1

    assert_eq!(sql, "s.account_id = $1");

23

1

    assert_eq!(offset, 1);

24

1

    assert!(matches!(&params[0], SqlParam::Uuid(v) if *v == id));

25

1

26

27

#[test]

28

1

fn test_to_sql_and_combinator() {

29

1

    let id1 = Uuid::new_v4();

30

1

    let id2 = Uuid::new_v4();

31

1

    let filter = ReportFilter::And(vec![

32

1

        ReportFilter::AccountEq(id1),

33

1

        ReportFilter::CommodityEq(id2),

34

1

]);

35

1

    let mut offset = 2;

36

1

    let (sql, params) = filter.to_sql(&mut offset);

37

1

    assert_eq!(sql, "(s.account_id = $3 AND s.commodity_id = $4)");

38

1

    assert_eq!(params.len(), 2);

39

1

    assert_eq!(offset, 4);

40

1

41

42

#[test]

43

1

fn test_to_sql_not() {

44

1

    let id = Uuid::new_v4();

45

1

    let filter = ReportFilter::Not(Box::new(ReportFilter::AccountEq(id)));

46

1

    let mut offset = 0;

47

1

    let (sql, _params) = filter.to_sql(&mut offset);

48

1

    assert_eq!(sql, "NOT (s.account_id = $1)");

49

1

50

51

#[test]

52

1

fn test_to_sql_amount_gt() {

53

1

    let r = Rational64::new(100, 1);

54

1

    let filter = ReportFilter::AmountGt(r);

55

1

    let mut offset = 0;

56

1

    let (sql, params) = filter.to_sql(&mut offset);

57

1

    assert_eq!(sql, "s.value_num * $2 > $1 * s.value_denom");

58

1

    assert_eq!(params.len(), 2);

59

1

    assert!(matches!(&params[0], SqlParam::I64(100)));

60

1

    assert!(matches!(&params[1], SqlParam::I64(1)));

61

1

62

63

#[test]

64

1

fn test_to_sql_counterparty_eq() {

65

1

    let id = Uuid::new_v4();

66

1

    let filter = ReportFilter::CounterpartyEq(id);

67

1

    let mut offset = 0;

68

1

    let (sql, _) = filter.to_sql(&mut offset);

69

1

    assert!(sql.contains("EXISTS"));

70

1

    assert!(sql.contains("o.account_id = $1"));

71

1

72

73

#[test]

74

1

fn test_to_sql_tag_filter() {

75

1

    let filter = ReportFilter::Tag {

76

1

        entity: FilterEntity::Account,

77

1

        name: "category".to_string(),

78

1

        value: "food".to_string(),

79

1

};

80

1

    let mut offset = 0;

81

1

    let (sql, params) = filter.to_sql(&mut offset);

82

1

    assert!(sql.contains("account_tags"));

83

1

    assert!(sql.contains("$1"));

84

1

    assert!(sql.contains("$2"));

85

1

    assert_eq!(params.len(), 2);

86

1

87

88

#[test]

89

1

fn test_to_sql_or_combinator() {

90

1

    let filter = ReportFilter::Or(vec![

91

1

        ReportFilter::AccountEq(Uuid::new_v4()),

92

1

        ReportFilter::AccountEq(Uuid::new_v4()),

93

1

]);

94

1

    let mut offset = 0;

95

1

    let (sql, _) = filter.to_sql(&mut offset);

96

1

    assert!(sql.contains(" OR "));

97

1

98

99

#[test]

100

1

fn test_to_sql_account_subtree() {

101

1

    let id = Uuid::new_v4();

102

1

    let filter = ReportFilter::AccountSubtree(id);

103

1

    let mut offset = 0;

104

1

    let (sql, params) = filter.to_sql(&mut offset);

105

1

    assert!(sql.contains("WITH RECURSIVE descendants"));

106

1

    assert!(sql.contains("$1"));

107

1

    assert_eq!(offset, 1);

108

1

    assert!(matches!(&params[0], SqlParam::Uuid(v) if *v == id));

109

1

110

111

#[test]

112

1

fn test_to_sql_account_in() {

113

1

    let ids = vec![Uuid::new_v4(), Uuid::new_v4()];

114

1

    let filter = ReportFilter::AccountIn(ids.clone());

115

1

    let mut offset = 0;

116

1

    let (sql, params) = filter.to_sql(&mut offset);

117

1

    assert_eq!(sql, "s.account_id = ANY($1)");

118

1

    assert!(matches!(&params[0], SqlParam::UuidVec(v) if v.len() == 2));

119

1

120

121

#[test]

122

1

fn test_build_tree_empty() {

123

1

    let accounts: Vec<AccountRow> = vec![];

124

1

    let amounts = AccountAmounts::new();

125

1

    let roots = build_tree(&accounts, &amounts);

126

1

    assert!(roots.is_empty());

127

1

128

129

#[test]

130

1

fn test_build_tree_single_account() {

131

1

    let id = Uuid::new_v4();

132

1

    let commodity_id = Uuid::new_v4();

133

1

    let accounts = vec![AccountRow {

134

1

        account_id: id,

135

1

        parent_id: None,

136

1

        account_name: "Assets".to_string(),

137

1

        account_type: None,

138

1

}];

139

1

    let mut amounts = AccountAmounts::new();

140

1

    amounts.insert(

141

1

id,

142

1

        [(commodity_id, (Rational64::new(100, 1), "USD".to_string()))]

143

1

            .into_iter()

144

1

            .collect(),

145

);

146

1

    let roots = build_tree(&accounts, &amounts);

147

1

    assert_eq!(roots.len(), 1);

148

1

    assert_eq!(roots[0].account_name, "Assets");

149

1

    assert_eq!(roots[0].account_path, "Assets");

150

1

    assert_eq!(roots[0].depth, 0);

151

1

    assert_eq!(roots[0].amounts.len(), 1);

152

1

    assert_eq!(roots[0].amounts[0].amount, Rational64::new(100, 1));

153

1

154

155

#[test]

156

1

fn test_build_tree_hierarchy() {

157

1

    let parent_id = Uuid::new_v4();

158

1

    let child_id = Uuid::new_v4();

159

1

    let commodity_id = Uuid::new_v4();

160

1

    let accounts = vec![

161

1

        AccountRow {

162

1

            account_id: parent_id,

163

1

            parent_id: None,

164

1

            account_name: "Assets".to_string(),

165

1

            account_type: None,

166

1

},

167

1

        AccountRow {

168

1

            account_id: child_id,

169

1

            parent_id: Some(parent_id),

170

1

            account_name: "Bank".to_string(),

171

1

            account_type: None,

172

1

},

173

];

174

1

    let mut amounts = AccountAmounts::new();

175

1

    amounts.insert(

176

1

        child_id,

177

1

        [(commodity_id, (Rational64::new(50, 1), "USD".to_string()))]

178

1

            .into_iter()

179

1

            .collect(),

180

);

181

1

    let roots = build_tree(&accounts, &amounts);

182

1

    assert_eq!(roots.len(), 1);

183

1

    assert_eq!(roots[0].children.len(), 1);

184

1

    assert_eq!(roots[0].children[0].account_path, "Assets:Bank");

185

1

    assert_eq!(roots[0].children[0].depth, 1);

186

1

    assert_eq!(roots[0].amounts[0].amount, Rational64::new(50, 1));

187

1

    assert_eq!(

188

1

        roots[0].children[0].amounts[0].amount,

189

1

        Rational64::new(50, 1)

190

);

191

1

192

193

#[test]

194

1

fn test_build_tree_prunes_empty_accounts() {

195

1

    let parent_id = Uuid::new_v4();

196

1

    let child_with_data = Uuid::new_v4();

197

1

    let child_empty = Uuid::new_v4();

198

1

    let empty_root = Uuid::new_v4();

199

1

    let commodity_id = Uuid::new_v4();

200

1

    let accounts = vec![

201

1

        AccountRow {

202

1

            account_id: parent_id,

203

1

            parent_id: None,

204

1

            account_name: "Assets".to_string(),

205

1

            account_type: None,

206

1

},

207

1

        AccountRow {

208

1

            account_id: child_with_data,

209

1

            parent_id: Some(parent_id),

210

1

            account_name: "Bank".to_string(),

211

1

            account_type: None,

212

1

},

213

1

        AccountRow {

214

1

            account_id: child_empty,

215

1

            parent_id: Some(parent_id),

216

1

            account_name: "Empty".to_string(),

217

1

            account_type: None,

218

1

},

219

1

        AccountRow {

220

1

            account_id: empty_root,

221

1

            parent_id: None,

222

1

            account_name: "Liabilities".to_string(),

223

1

            account_type: None,

224

1

},

225

];

226

1

    let mut amounts = AccountAmounts::new();

227

1

    amounts.insert(

228

1

        child_with_data,

229

1

        [(commodity_id, (Rational64::new(100, 1), "USD".to_string()))]

230

1

            .into_iter()

231

1

            .collect(),

232

);

233

1

    let roots = build_tree(&accounts, &amounts);

234

1

    assert_eq!(roots.len(), 1, "empty root Liabilities should be pruned");

235

1

    assert_eq!(roots[0].account_name, "Assets");

236

1

    assert_eq!(

237

1

        roots[0].children.len(),

238

1,

239

        "empty child Empty should be pruned"

240

);

241

1

    assert_eq!(roots[0].children[0].account_name, "Bank");

242

1

243

244

#[test]

245

1

fn test_generate_month_boundaries() {

246

1

    let from = NaiveDate::from_ymd_opt(2025, 1, 15)

247

1

        .unwrap()

248

1

        .and_hms_opt(0, 0, 0)

249

1

        .unwrap()

250

1

        .and_utc();

251

1

    let to = NaiveDate::from_ymd_opt(2025, 4, 1)

252

1

        .unwrap()

253

1

        .and_hms_opt(0, 0, 0)

254

1

        .unwrap()

255

1

        .and_utc();

256

1

    let boundaries = generate_month_boundaries(from, to);

257

1

    assert_eq!(boundaries.len(), 3);

258

1

    assert_eq!(boundaries[0].0, "2025-01");

259

1

    assert_eq!(boundaries[1].0, "2025-02");

260

1

    assert_eq!(boundaries[2].0, "2025-03");

261

1

262

263

#[test]

264

1

fn test_generate_quarter_boundaries() {

265

1

    let from = NaiveDate::from_ymd_opt(2025, 1, 1)

266

1

        .unwrap()

267

1

        .and_hms_opt(0, 0, 0)

268

1

        .unwrap()

269

1

        .and_utc();

270

1

    let to = NaiveDate::from_ymd_opt(2025, 7, 1)

271

1

        .unwrap()

272

1

        .and_hms_opt(0, 0, 0)

273

1

        .unwrap()

274

1

        .and_utc();

275

1

    let boundaries = generate_quarter_boundaries(from, to);

276

1

    assert_eq!(boundaries.len(), 2);

277

1

    assert_eq!(boundaries[0].0, "2025-Q1");

278

1

    assert_eq!(boundaries[1].0, "2025-Q2");

279

1

280

281

#[test]

282

1

fn test_generate_year_boundaries() {

283

1

    let from = NaiveDate::from_ymd_opt(2024, 6, 1)

284

1

        .unwrap()

285

1

        .and_hms_opt(0, 0, 0)

286

1

        .unwrap()

287

1

        .and_utc();

288

1

    let to = NaiveDate::from_ymd_opt(2026, 3, 1)

289

1

        .unwrap()

290

1

        .and_hms_opt(0, 0, 0)

291

1

        .unwrap()

292

1

        .and_utc();

293

1

    let boundaries = generate_year_boundaries(from, to);

294

1

    assert_eq!(boundaries.len(), 3);

295

1

    assert_eq!(boundaries[0].0, "2024");

296

1

    assert_eq!(boundaries[1].0, "2025");

297

1

    assert_eq!(boundaries[2].0, "2026");

298

1

299

300

#[test]

301

1

fn test_accumulate_split_converted_same_commodity() {

302

1

    let mut amounts = AccountAmounts::new();

303

1

    let account_id = Uuid::new_v4();

304

1

    let commodity_id = Uuid::new_v4();

305

1

    let target = ConversionTarget {

306

1

        commodity_id,

307

1

        symbol: "USD",

308

1

};

309

1

    let result = accumulate_split_converted(

310

1

        &mut amounts,

311

1

        account_id,

312

1

        commodity_id,

313

1

        Rational64::new(100, 1),

314

1

        "USD",

315

1

        &target,

316

1

        (None, None),

317

);

318

1

    assert!(result.is_ok());

319

1

    assert_eq!(

320

1

        amounts[&account_id][&commodity_id].0,

321

1

        Rational64::new(100, 1)

322

);

323

1

324

325

#[test]

326

1

fn test_accumulate_split_converted_with_price() {

327

1

    let mut amounts = AccountAmounts::new();

328

1

    let account_id = Uuid::new_v4();

329

1

    let from_commodity = Uuid::new_v4();

330

1

    let target_commodity = Uuid::new_v4();

331

1

    let target = ConversionTarget {

332

1

        commodity_id: target_commodity,

333

1

        symbol: "USD",

334

1

};

335

1

    let result = accumulate_split_converted(

336

1

        &mut amounts,

337

1

        account_id,

338

1

        from_commodity,

339

1

        Rational64::new(100, 1),

340

1

        "EUR",

341

1

        &target,

342

1

        (Some(1176), Some(1000)),

343

);

344

1

    assert!(result.is_ok());

345

1

    assert_eq!(

346

1

        amounts[&account_id][&target_commodity].0,

347

1

        Rational64::new(100, 1) * Rational64::new(1176, 1000)

348

);

349

1

350

351

#[test]

352

1

fn test_accumulate_split_converted_missing_price() {

353

1

    let mut amounts = AccountAmounts::new();

354

1

    let target = ConversionTarget {

355

1

        commodity_id: Uuid::new_v4(),

356

1

        symbol: "USD",

357

1

};

358

1

    let result = accumulate_split_converted(

359

1

        &mut amounts,

360

1

        Uuid::new_v4(),

361

1

        Uuid::new_v4(),

362

1

        Rational64::new(100, 1),

363

1

        "EUR",

364

1

        &target,

365

1

        (None, None),

366

);

367

1

    assert!(result.is_err());

368

1

    let err = result.unwrap_err();

369

1

    assert!(matches!(err, ReportError::MissingConversion { .. }));

370

1

371

372

mod sexpr_tests {

373

    use super::*;

374

375

    #[test]

376

1

    fn test_from_sexpr_account_eq() {

377

1

        let id = Uuid::new_v4();

378

1

        let input = format!("(account= \"{id}\")");

379

1

        let filter = ReportFilter::from_sexpr(&input).unwrap();

380

1

        assert!(matches!(filter, ReportFilter::AccountEq(v) if v == id));

381

1

382

383

    #[test]

384

1

    fn test_from_sexpr_commodity_eq() {

385

1

        let id = Uuid::new_v4();

386

1

        let input = format!("(commodity= \"{id}\")");

387

1

        let filter = ReportFilter::from_sexpr(&input).unwrap();

388

1

        assert!(matches!(filter, ReportFilter::CommodityEq(v) if v == id));

389

1

390

391

    #[test]

392

1

    fn test_from_sexpr_amount_gt() {

393

1

        let input = "(amount> 100)";

394

1

        let filter = ReportFilter::from_sexpr(input).unwrap();

395

1

        assert!(matches!(filter, ReportFilter::AmountGt(r) if r == Rational64::new(100, 1)));

396

1

397

398

    #[test]

399

1

    fn test_from_sexpr_and() {

400

1

        let id1 = Uuid::new_v4();

401

1

        let id2 = Uuid::new_v4();

402

1

        let input = format!("(and (account= \"{id1}\") (commodity= \"{id2}\"))");

403

1

        let filter = ReportFilter::from_sexpr(&input).unwrap();

404

1

        assert!(matches!(filter, ReportFilter::And(v) if v.len() == 2));

405

1

406

407

    #[test]

408

1

    fn test_from_sexpr_not() {

409

1

        let id = Uuid::new_v4();

410

1

        let input = format!("(not (account= \"{id}\"))");

411

1

        let filter = ReportFilter::from_sexpr(&input).unwrap();

412

1

        assert!(matches!(filter, ReportFilter::Not(_)));

413

1

414

415

    #[test]

416

1

    fn test_from_sexpr_tag() {

417

1

        let input = "(account-tag= \"category\" \"food\")";

418

1

        let filter = ReportFilter::from_sexpr(input).unwrap();

419

1

        match filter {

420

            ReportFilter::Tag {

421

1

                entity,

422

1

                name,

423

1

                value,

424

            } => {

425

1

                assert!(matches!(entity, FilterEntity::Account));

426

1

                assert_eq!(name, "category");

427

1

                assert_eq!(value, "food");

428

429

            _ => panic!("Expected Tag filter"),

430

431

1

432

433

    #[test]

434

1

    fn test_from_sexpr_account_subtree() {

435

1

        let id = Uuid::new_v4();

436

1

        let input = format!("(account-subtree \"{id}\")");

437

1

        let filter = ReportFilter::from_sexpr(&input).unwrap();

438

1

        assert!(matches!(filter, ReportFilter::AccountSubtree(v) if v == id));

439

1

440

441

    #[test]

442

1

    fn test_from_sexpr_invalid() {

443

1

        let result = ReportFilter::from_sexpr("invalid");

444

1

        assert!(result.is_err());

445

1

446

447

    #[test]

448

1

    fn test_from_sexpr_counterparty() {

449

1

        let id = Uuid::new_v4();

450

1

        let input = format!("(counterparty= \"{id}\")");

451

1

        let filter = ReportFilter::from_sexpr(&input).unwrap();

452

1

        assert!(matches!(filter, ReportFilter::CounterpartyEq(v) if v == id));

453

1

454

455

    #[test]

456

1

    fn test_from_sexpr_or() {

457

1

        let id1 = Uuid::new_v4();

458

1

        let id2 = Uuid::new_v4();

459

1

        let input = format!("(or (account= \"{id1}\") (account= \"{id2}\"))");

460

1

        let filter = ReportFilter::from_sexpr(&input).unwrap();

461

1

        assert!(matches!(filter, ReportFilter::Or(v) if v.len() == 2));

462

1

463

464

465

#[test]

466

1

fn test_period_grouping_deserializes_from_web_forms() {

467

1

    let cases = [

468

1

        ("\"month\"", PeriodGrouping::Month),

469

1

        ("\"quarter\"", PeriodGrouping::Quarter),

470

1

        ("\"year\"", PeriodGrouping::Year),

471

1

];

472

3

    for (input, expected) in cases {

473

3

        let parsed: PeriodGrouping = serde_json::from_str(input).unwrap();

474

3

        assert_eq!(parsed, expected);

475

476

1

477

478

#[test]

479

1

fn test_period_grouping_rejects_invalid() {

480

1

    assert!(serde_json::from_str::<PeriodGrouping>("\"weekly\"").is_err());

481

1

482

483

#[test]

484

1

fn test_breakdown_sort_deserializes_from_web_forms() {

485

1

    let cases = [

486

1

        ("\"amount_desc\"", BreakdownSort::AmountDesc),

487

1

        ("\"amount_asc\"", BreakdownSort::AmountAsc),

488

1

        ("\"name_asc\"", BreakdownSort::NameAsc),

489

1

        ("\"name_desc\"", BreakdownSort::NameDesc),

490

1

];

491

4

    for (input, expected) in cases {

492

4

        let parsed: BreakdownSort = serde_json::from_str(input).unwrap();

493

4

        assert_eq!(parsed, expected);

494

495

1

496

497

#[test]

498

1

fn test_breakdown_sort_default_is_amount_desc() {

499

1

    assert_eq!(BreakdownSort::default(), BreakdownSort::AmountDesc);

500

1

501

502

#[test]

503

1

fn test_activity_group_serde_round_trip() {

504

    use super::super::ActivityGroup;

505

1

    let g = ActivityGroup {

506

1

        label: "Savings".into(),

507

1

        filter: ReportFilter::Tag {

508

1

            entity: FilterEntity::Account,

509

1

            name: "type".into(),

510

1

            value: "savings".into(),

511

1

},

512

1

        flip_sign: true,

513

1

};

514

1

    let json = serde_json::to_string(&g).unwrap();

515

1

    let parsed: ActivityGroup = serde_json::from_str(&json).unwrap();

516

1

    assert_eq!(parsed.label, g.label);

517

1

    assert_eq!(parsed.flip_sign, g.flip_sign);

518

    // filter equality: easier to compare via re-serialization

519

1

    let re_json = serde_json::to_string(&parsed).unwrap();

520

1

    assert_eq!(json, re_json);

521

1

522

523

#[test]

524

1

fn test_activity_group_flip_sign_defaults_false() {

525

    use super::super::ActivityGroup;

526

1

    let json = r#"{"label":"Expense","filter":{"op":"tag","args":{"entity":"account","name":"type","value":"expense"}}}"#;

527

1

    let parsed: ActivityGroup = serde_json::from_str(json).unwrap();

528

1

    assert!(!parsed.flip_sign);

529

1

530

531

/// A range ending at chrono's last representable year must terminate.

532

///

533

/// `%Y-%m-%d` parses `+262142-12-01` from the report's own query parameters, and

534

/// the `next_*` helpers step past `NaiveDate::MAX`. If that step yields anything

535

/// below `to`, the generators walk backwards and loop forever, allocating as

536

/// they go — an authenticated request that never returns.

537

#[test]

538

1

fn boundaries_terminate_at_the_end_of_representable_time() {

539

1

    let from = NaiveDate::from_ymd_opt(262_142, 12, 1)

540

1

        .and_then(|d| d.and_hms_opt(0, 0, 0))

541

1

        .expect("last representable month")

542

1

        .and_utc();

543

1

    let to = NaiveDate::from_ymd_opt(262_142, 12, 31)

544

1

        .and_then(|d| d.and_hms_opt(23, 59, 59))

545

1

        .expect("last representable day")

546

1

        .and_utc();

547

548

3

    for periods in [

549

1

        generate_month_boundaries(from, to),

550

1

        generate_quarter_boundaries(from, to),

551

1

        generate_year_boundaries(from, to),

552

1

] {

553

3

        assert_eq!(periods.len(), 1, "one period, not an unbounded walk");

554

3

        assert_eq!(periods[0].2, to, "the final period is clamped to `to`");

555

556

1

557

558

/// A range wider than a report can usefully be must be refused, not generated.

559

///

560

/// The callers issue one query per period per group, so `+262142-12-31` — which

561

/// `%Y-%m-%d` accepts from a query parameter — would otherwise mean millions of

562

/// sequential queries against a cluster shared with other tenants.

563

#[test]

564

1

fn an_absurd_report_range_is_refused() {

565

1

    let from = NaiveDate::from_ymd_opt(2026, 1, 1)

566

1

        .and_then(|d| d.and_hms_opt(0, 0, 0))

567

1

        .expect("valid")

568

1

        .and_utc();

569

1

    let to = NaiveDate::from_ymd_opt(262_142, 12, 31)

570

1

        .and_then(|d| d.and_hms_opt(0, 0, 0))

571

1

        .expect("valid")

572

1

        .and_utc();

573

574

3

    for grouping in [

575

1

        PeriodGrouping::Month,

576

1

        PeriodGrouping::Quarter,

577

1

        PeriodGrouping::Year,

578

1

] {

579

3

        assert!(

580

3

            boundaries(grouping, from, to).is_err(),

581

            "an unbounded span must be refused, not walked"

582

);

583

584

1

    assert!(

585

1

        boundaries(PeriodGrouping::Month, to, from).is_err(),

586

        "an inverted range must be refused"

587

);

588

1

    assert!(

589

1

        boundaries(PeriodGrouping::Month, from, from).is_err(),

590

        "an empty range must be refused"

591

);

592

1

    assert!(

593

1

        boundaries(

594

1

            PeriodGrouping::Month,

595

1

            from,

596

1

            NaiveDate::from_ymd_opt(2027, 1, 1)

597

1

                .and_then(|d| d.and_hms_opt(0, 0, 0))

598

1

                .expect("valid")

599

1

                .and_utc()

600

601

1

        .is_ok(),

602

        "an ordinary range still works"

603

);

604

1

605

606

/// The first bucket is aligned to its calendar unit, so without clamping the

607

/// report would sum transactions from before the requested start and contradict

608

/// the `date_from` it echoes back.

609

#[test]

610

1

fn the_first_period_never_starts_before_the_requested_range() {

611

2

    let at = |y, m, d| {

612

2

        NaiveDate::from_ymd_opt(y, m, d)

613

2

            .and_then(|x| x.and_hms_opt(0, 0, 0))

614

2

            .expect("valid")

615

2

            .and_utc()

616

2

};

617

1

    let from = at(2026, 5, 15);

618

1

    let to = at(2026, 8, 20);

619

620

3

    for grouping in [

621

1

        PeriodGrouping::Month,

622

1

        PeriodGrouping::Quarter,

623

1

        PeriodGrouping::Year,

624

1

] {

625

3

        let periods = boundaries(grouping, from, to).expect("an ordinary range");

626

3

        assert_eq!(

627

3

            periods.first().expect("at least one period").1,

628

            from,

629

            "{grouping:?} must not reach back before `from`"

630

);

631

7

        assert!(periods.iter().all(|p| p.1 >= from && p.2 <= to));

632

633

1

634

635

/// The report runs one query per period PER GROUP. Bounding only the periods

636

/// leaves the product unbounded — `groups` is JSON on the query string with no

637

/// length of its own.

638

#[test]

639

1

fn the_query_budget_bounds_periods_times_groups() {

640

    use super::period::query_budget;

641

642

1

    assert!(

643

1

        query_budget(600, 6, 4096).is_ok(),

644

        "an ordinary report runs"

645

);

646

1

    assert!(

647

1

        query_budget(600, 7, 4096).is_err(),

648

        "the same span with one more group exceeds the budget"

649

);

650

    // The ungrouped path still issues one query per group.

651

1

    assert!(

652

1

        query_budget(0, 5000, 4096).is_err(),

653

        "groups alone are bounded"

654

);

655

1

    assert!(query_budget(0, 0, 4096).is_ok(), "no groups, no queries");

656

1

657

658

/// The cap is counted in the grouping actually requested: a 51-year YEARLY

659

/// report is 51 rows and must not be refused for spanning 612 months.

660

#[test]

661

1

fn the_span_cap_counts_the_requested_grouping() {

662

4

    let at = |y| {

663

4

        NaiveDate::from_ymd_opt(y, 1, 1)

664

4

            .and_then(|d| d.and_hms_opt(0, 0, 0))

665

4

            .expect("valid")

666

4

            .and_utc()

667

4

};

668

1

    assert!(

669

1

        boundaries(PeriodGrouping::Year, at(1975), at(2026)).is_ok(),

670

        "51 years of yearly rows is a legitimate report"

671

);

672

1

    assert!(

673

1

        boundaries(PeriodGrouping::Month, at(1975), at(2026)).is_err(),

674

        "the same span monthly is 612 rows and is refused"

675

);

676

1

677

678

/// Bounding how many queries run says nothing about the cost of each one: a

679

/// caller-shaped filter becomes bind parameters and correlated subqueries.

680

#[test]

681

1

fn filter_leaves_are_counted_for_the_size_bound() {

682

1

    let leaf = ReportFilter::AccountEq(Uuid::new_v4());

683

1

    assert_eq!(leaf.leaves(), 1);

684

685

1

    let wide = ReportFilter::Or(

686

1

        (0..50)

687

50

            .map(|_| ReportFilter::AccountEq(Uuid::new_v4()))

688

1

            .collect(),

689

);

690

1

    assert_eq!(wide.leaves(), 50);

691

692

30

    let ids: Vec<Uuid> = (0..30).map(|_| Uuid::new_v4()).collect();

693

1

    assert_eq!(

694

1

        ReportFilter::AccountIn(ids).leaves(),

695

30,

696

        "an In list is its length"

697

);

698

699

1

    let nested = ReportFilter::Not(Box::new(ReportFilter::And(vec![

700

        ReportFilter::Or(

701

1

            (0..40)

702

40

                .map(|_| ReportFilter::AccountEq(Uuid::new_v4()))

703

1

                .collect(),

704

),

705

1

        ReportFilter::AccountEq(Uuid::new_v4()),

706

    ])));

707

1

    assert_eq!(nested.leaves(), 41, "nesting does not hide leaves");

708

1

    assert!(nested.leaves() < super::filter::MAX_FILTER_LEAVES);

709

1

710

711

/// Every command that accepts a filter must enforce the size cap. Guarding one

712

/// of the three is how the bound ends up protecting a single caller — which is

713

/// exactly how this defect was introduced.

714

#[test]

715

1

fn every_filter_accepting_command_enforces_the_size_cap() {

716

1

    let sources = [

717

1

        include_str!("activity.rs"),

718

1

        include_str!("balance.rs"),

719

1

        include_str!("category_breakdown.rs"),

720

1

];

721

3

    for src in sources {

722

3

        assert!(

723

3

            src.contains("check_filter_size"),

724

            "a command accepts `report_filter` without checking its size"

725

);

726

727

1

728

729

/// The cap itself: an over-large filter is refused, an ordinary one is not.

730

#[test]

731

1

fn the_filter_size_cap_refuses_an_oversized_filter() {

732

    use super::filter::{MAX_FILTER_LEAVES, check_filter_size};

733

734

1

    assert!(check_filter_size(MAX_FILTER_LEAVES).is_ok());

735

1

    assert!(check_filter_size(MAX_FILTER_LEAVES + 1).is_err());

736

1

    assert!(check_filter_size(0).is_ok(), "no filter is not an error");

737

1

738

739

/// Each refusal must name the dimension the caller actually blew, with the real

740

/// numbers. A bound that fires with the wrong message sends the user to change

741

/// the wrong thing.

742

#[test]

743

1

fn every_report_refusal_reports_its_own_dimension() {

744

    use super::activity::MAX_QUERIES;

745

    use super::filter::{MAX_FILTER_LEAVES, check_filter_size};

746

    use super::period::query_budget;

747

    use crate::command::CmdError;

748

749

5

    let msg = |err: CmdError| match err {

750

5

        CmdError::Args(m) => m,

751

        other => panic!("every report refusal must be `Args`, got {other:?}"),

752

5

};

753

6

    let at = |y, m, d| {

754

6

        NaiveDate::from_ymd_opt(y, m, d)

755

6

            .and_then(|x| x.and_hms_opt(0, 0, 0))

756

6

            .expect("valid")

757

6

            .and_utc()

758

6

};

759

760

    // Too many queries: names the count and the budget, not the filter.

761

1

    let m = msg(query_budget(600, 100, MAX_QUERIES).expect_err("60000 queries"));

762

1

    assert!(

763

1

        m.contains("60000") && m.contains(&MAX_QUERIES.to_string()),

764

        "{m}"

765

);

766

1

    assert!(

767

1

        m.contains("queries"),

768

        "must name queries, not conditions: {m}"

769

);

770

771

    // Too big a filter: names the conditions and the cap, not the query count.

772

1

    let m = msg(check_filter_size(MAX_FILTER_LEAVES + 1).expect_err("65 leaves"));

773

1

    assert!(

774

1

        m.contains("65") && m.contains(&MAX_FILTER_LEAVES.to_string()),

775

        "{m}"

776

);

777

1

    assert!(

778

1

        m.contains("conditions"),

779

        "must name conditions, not queries: {m}"

780

);

781

782

    // Inverted range, and its equal-bounds twin.

783

2

    for (from, to) in [

784

1

        (at(2026, 5, 2), at(2026, 5, 1)),

785

1

        (at(2026, 5, 1), at(2026, 5, 1)),

786

1

] {

787

2

        let m = msg(boundaries(PeriodGrouping::Month, from, to).expect_err("bad range"));

788

2

        assert!(m.contains("ends before it starts"), "{m}");

789

790

791

    // Too wide a span: names periods in the requested grouping.

792

1

    let m =

793

1

        msg(boundaries(PeriodGrouping::Month, at(1900, 1, 1), at(2026, 1, 1)).expect_err("wide"));

794

1

    assert!(m.contains("periods") && m.contains("600"), "{m}");

795

1

796

797

/// The per-query cost is the report filter plus the LARGEST group, because each

798

/// query is `And(group.filter, report_filter)` for one group. Summing refuses

799

/// requests that cost nothing near the bound.

800

#[test]

801

1

fn the_widest_query_is_the_largest_group_not_their_sum() {

802

    use super::activity::widest_query_leaves;

803

    use crate::command::ActivityGroup;

804

805

1

    let one = |n: usize| ActivityGroup {

806

102

        label: String::new(),

807

        filter: ReportFilter::Or(

808

102

            (0..n)

809

125

                .map(|_| ReportFilter::AccountEq(Uuid::new_v4()))

810

102

                .collect(),

811

),

812

        flip_sign: false,

813

102

};

814

815

100

    let many_small: Vec<ActivityGroup> = (0..100).map(|_| one(1)).collect();

816

1

    assert_eq!(

817

1

        widest_query_leaves(None, &many_small),

818

1,

819

        "100 one-condition groups are 100 queries of ONE leaf, not a 100-leaf query"

820

);

821

1

    assert!(

822

1

        super::filter::check_filter_size(widest_query_leaves(None, &many_small)).is_ok(),

823

        "a legitimate many-group report must not be refused for filter size"

824

);

825

826

    // The report filter still adds to whichever group is widest.

827

1

    let report = ReportFilter::Or(

828

1

        (0..10)

829

10

            .map(|_| ReportFilter::AccountEq(Uuid::new_v4()))

830

1

            .collect(),

831

);

832

1

    assert_eq!(widest_query_leaves(Some(&report), &[one(5), one(20)]), 30);

833

1

    assert_eq!(

834

1

        widest_query_leaves(None, &[]),

835

0,

836

        "no groups, no filter, no cost"

837

);

838

1

839

840

/// The cap must count what the generators actually emit. The old estimate

841

/// rounded the elapsed month count, which refused a 600-month report and let

842

/// 601 quarters and 601 years straight through.

843

#[test]

844

1

fn the_period_cap_counts_the_buckets_that_will_be_generated() {

845

8

    let at = |y: i32, m: u32, d: u32| {

846

8

        NaiveDate::from_ymd_opt(y, m, d)

847

8

            .expect("valid date")

848

8

            .and_hms_opt(0, 0, 0)

849

8

            .expect("valid time")

850

8

            .and_utc()

851

8

};

852

853

    // Exactly 600 monthly buckets: allowed, and 600 of them.

854

1

    let months = boundaries(PeriodGrouping::Month, at(2000, 1, 1), at(2050, 1, 1))

855

1

        .expect("600 months is within the cap");

856

1

    assert_eq!(months.len(), 600);

857

858

    // 601 buckets, one over: refused for every grouping, including the two

859

    // that used to slip past because the estimate undercounted.

860

3

    for (grouping, from, to) in [

861

1

        (PeriodGrouping::Month, at(2000, 1, 1), at(2050, 2, 1)),

862

1

        (PeriodGrouping::Quarter, at(2000, 3, 1), at(2150, 1, 2)),

863

1

        (PeriodGrouping::Year, at(2000, 12, 1), at(2600, 1, 2)),

864

1

] {

865

3

        let err = boundaries(grouping, from, to).expect_err("601 buckets must be refused");

866

3

        assert!(

867

3

            format!("{err:?}").contains("601"),

868

            "must report the real bucket count: {err:?}"

869

);

870

871

1

872

873

/// An empty `And`/`Or` used to render as `()`, a Postgres syntax error the

874

/// user could trigger with `(and)` — a 500 where a filter should just be

875

/// vacuous. Reachable from the activity `groups` JSON too, which never passes

876

/// through the s-expression parser.

877

#[test]

878

1

fn an_empty_conjunction_renders_as_its_identity() {

879

1

    assert_eq!(ReportFilter::And(vec![]).to_sql(&mut 1).0, "TRUE");

880

1

    assert_eq!(ReportFilter::Or(vec![]).to_sql(&mut 1).0, "FALSE");

881

1

    let nested = ReportFilter::And(vec![

882

1

        ReportFilter::AccountEq(Uuid::nil()),

883

1

        ReportFilter::Or(vec![]),

884

1

]);

885

1

    assert!(

886

1

        !nested.to_sql(&mut 1).0.contains("()"),

887

        "an empty child must not leave an empty parenthesis in the SQL"

888

);

889

1

890

891

/// `from_sexpr` parsed one expression and threw away the rest, so a second

892

/// condition silently did not apply.

893

#[test]

894

1

fn a_filter_must_be_exactly_one_expression() {

895

1

    let one = format!("(account= \"{}\")", Uuid::nil());

896

1

    ReportFilter::from_sexpr(&one).expect("one expression parses");

897

1

    let two = format!("{one} {one}");

898

1

    assert!(

899

1

        ReportFilter::from_sexpr(&two).is_err(),

900

        "the second condition must not be dropped"

901

);

902

1

    assert!(ReportFilter::from_sexpr("").is_err());

903

1

904

905

/// A leap second is a representable `DateTime<Utc>` STRICTLY GREATER than

906

/// `MAX_UTC`, which every `next_*` saturates to — so the generator stepped to

907

/// `MAX_UTC`, stayed `< to`, and appended periods until memory ran out.

908

#[test]

909

1

fn a_leap_second_end_does_not_run_the_generator_forever() {

910

1

    let leap = chrono::NaiveDate::MAX

911

1

        .and_hms_nano_opt(23, 59, 59, 1_000_000_000)

912

1

        .expect("chrono represents a leap second")

913

1

        .and_utc();

914

1

    assert!(leap > chrono::DateTime::<chrono::Utc>::MAX_UTC);

915

1

    let from = NaiveDate::from_ymd_opt(262_142, 12, 1)

916

1

        .expect("valid date")

917

1

        .and_hms_opt(0, 0, 0)

918

1

        .expect("valid time")

919

1

        .and_utc();

920

1

    let periods = boundaries(PeriodGrouping::Month, from, leap).expect("one month");

921

1

    assert_eq!(periods.len(), 1);

922

1

923

924

/// Extra arguments were dropped in silence, so a second condition the user

925

/// wrote simply did not apply.

926

#[test]

927

1

fn a_filter_operator_refuses_extra_arguments() {

928

1

    assert!(ReportFilter::from_sexpr("(amount> 0 (amount< 100))").is_err());

929

1

    assert!(ReportFilter::from_sexpr(&format!("(account= \"{}\" 1)", Uuid::nil())).is_err());

930

1

    assert!(ReportFilter::from_sexpr("(transaction-tag= \"a\" \"b\" \"c\")").is_err());

931

    // The variadic and single-argument forms still parse.

932

1

    ReportFilter::from_sexpr("(and (amount> 0) (amount< 100))").expect("and is variadic");

933

1

    ReportFilter::from_sexpr("(amount> 0)").expect("one argument is right");

934

1

935

936

/// `parse_uuid_list_arg` consumes every remaining argument, so the `*-in`

937

/// forms are variadic; an arity table that called them one-argument silently

938

/// broke every multi-account filter.

939

#[test]

940

1

fn the_in_operators_take_more_than_one_id() {

941

1

    let two = format!("(account-in \"{}\" \"{}\")", Uuid::nil(), Uuid::max());

942

1

    let filter = ReportFilter::from_sexpr(&two).expect("account-in is variadic");

943

1

    assert!(matches!(filter, ReportFilter::AccountIn(ids) if ids.len() == 2));

944

2

    for op in ["counterparty-in", "commodity-in"] {

945

2

        ReportFilter::from_sexpr(&format!("({op} \"{}\" \"{}\")", Uuid::nil(), Uuid::max()))

946

2

            .unwrap_or_else(|e| panic!("{op} is variadic: {e:?}"));

947

948

    // Still bounded below: an empty list is not a filter.

949

1

    assert!(ReportFilter::from_sexpr("(account-in)").is_err());

950

1

951

952

/// A reversed range is refused whether or not the report is grouped: without

953

/// the shared check an ungrouped one matched nothing and returned an empty 200.

954

#[test]

955

1

fn a_reversed_range_is_refused_without_grouping() {

956

6

    let at = |d: u32| {

957

6

        NaiveDate::from_ymd_opt(2026, 9, d)

958

6

            .expect("valid date")

959

6

            .and_hms_opt(0, 0, 0)

960

6

            .expect("valid time")

961

6

            .and_utc()

962

6

};

963

1

    assert!(check_range(at(10), at(1)).is_err());

964

1

    assert!(

965

1

        check_range(at(1), at(1)).is_err(),

966

        "an empty range ends as it starts"

967

);

968

1

    assert!(check_range(at(1), at(10)).is_ok());

969

1