Grcov report - test_account

1

use axum::{

2

    Router,

3

    body::Body,

4

    http::{Request, StatusCode, header},

5

    routing::{get, post},

6

};

7

use serde_json::json;

8

use tower::ServiceExt;

9

10

use crate::common::{create_mock_jwt_auth, create_mock_user, create_test_app_state};

11

use serde_json::Value;

12

13

#[tokio::test]

14

1

async fn test_account_create_without_auth() {

15

1

    let app_state = create_test_app_state().await;

16

1

    let app = Router::new()

17

1

        .route(

18

1

            "/account/create/submit",

19

1

            post(web::pages::account::create::submit::create_account),

20

21

1

        .with_state(app_state);

22

23

1

    let account_data = json!({

24

1

        "name": "Test Account",

25

1

        "parent_id": null

26

});

27

28

1

    let response = app

29

1

        .oneshot(

30

1

            Request::builder()

31

1

                .method("POST")

32

1

                .uri("/account/create/submit")

33

1

                .header("content-type", "application/json")

34

1

                .body(Body::from(account_data.to_string()))

35

1

                .unwrap(),

36

1

37

1

        .await

38

1

        .unwrap();

39

40

    // Should fail without authentication - expecting 401 or 500

41

1

    assert!(response.status().is_client_error() || response.status().is_server_error());

42

1

43

44

#[tokio::test]

45

1

async fn test_account_create_with_invalid_json() {

46

1

    let app_state = create_test_app_state().await;

47

1

    let app = Router::new()

48

1

        .route(

49

1

            "/account/create/submit",

50

1

            post(web::pages::account::create::submit::create_account),

51

52

1

        .with_state(app_state);

53

54

1

    let response = app

55

1

        .oneshot(

56

1

            Request::builder()

57

1

                .method("POST")

58

1

                .uri("/account/create/submit")

59

1

                .header("content-type", "application/json")

60

1

                .body(Body::from("invalid json"))

61

1

                .unwrap(),

62

1

63

1

        .await

64

1

        .unwrap();

65

66

    // Should fail without authentication - expecting 401 or 500

67

1

    assert!(response.status().is_client_error() || response.status().is_server_error());

68

1

69

70

#[tokio::test]

71

1

async fn test_account_create_with_mock_auth() {

72

1

    let app_state = create_test_app_state().await;

73

1

    let mock_user = create_mock_user();

74

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

75

76

1

    let app = Router::new()

77

1

        .route(

78

1

            "/account/create/submit",

79

1

            post(web::pages::account::create::submit::create_account),

80

81

1

        .layer(axum::middleware::from_fn_with_state(

82

1

            app_state.clone(),

83

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

84

1

                let jwt_auth = jwt_auth.clone();

85

1

                async move {

86

1

                    req.extensions_mut().insert(jwt_auth);

87

1

                    next.run(req).await

88

1

89

1

},

90

))

91

1

        .with_state(app_state.clone());

92

93

1

    let account_data = json!({

94

1

        "name": "Test Account",

95

1

        "parent_id": null

96

});

97

98

1

    let response = app

99

1

        .oneshot(

100

1

            Request::builder()

101

1

                .method("POST")

102

1

                .uri("/account/create/submit")

103

1

                .header("content-type", "application/json")

104

1

                .body(Body::from(account_data.to_string()))

105

1

                .unwrap(),

106

1

107

1

        .await

108

1

        .unwrap();

109

110

    // This test verifies our CreateAccount macro integration works

111

    // Even if it fails due to DB issues, it should not be a JSON parsing error

112

    // We expect either success (200) or a server error (500) due to missing DB

113

    // but NOT a client error (400) which would indicate API issues

114

1

    assert!(

115

1

        response.status().is_success() || response.status().is_server_error(),

116

        "Expected success or server error, got: {}",

117

        response.status()

118

);

119

120

    // If we get a response, verify it has proper content type

121

1

    if let Some(content_type) = response.headers().get("content-type") {

122

1

        let content_type_str = content_type.to_str().unwrap_or("");

123

1

        // Should be text (for success message) or JSON (for error response)

124

1

        assert!(

125

1

            content_type_str.contains("text/") || content_type_str.contains("application/json"),

126

1

            "Unexpected content type: {content_type_str}"

127

1

);

128

1

129

1

130

131

#[tokio::test]

132

1

async fn test_account_create_invalid_parent_id_format() {

133

1

    let app_state = create_test_app_state().await;

134

1

    let mock_user = create_mock_user();

135

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

136

137

1

    let app = Router::new()

138

1

        .route(

139

1

            "/account/create/submit",

140

1

            post(web::pages::account::create::submit::create_account),

141

142

1

        .layer(axum::middleware::from_fn_with_state(

143

1

            app_state.clone(),

144

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

145

1

                let jwt_auth = jwt_auth.clone();

146

1

                async move {

147

1

                    req.extensions_mut().insert(jwt_auth);

148

1

                    next.run(req).await

149

1

150

1

},

151

))

152

1

        .with_state(app_state.clone());

153

154

1

    let account_data = json!({

155

1

        "name": "Test Account",

156

1

        "parent_id": "invalid_parent_id"

157

});

158

159

1

    let response = app

160

1

        .oneshot(

161

1

            Request::builder()

162

1

                .method("POST")

163

1

                .uri("/account/create/submit")

164

1

                .header("content-type", "application/json")

165

1

                .body(Body::from(account_data.to_string()))

166

1

                .unwrap(),

167

1

168

1

        .await

169

1

        .unwrap();

170

171

    // Should return 400 for invalid parent UUID format

172

1

    assert_eq!(response.status(), StatusCode::BAD_REQUEST);

173

174

    // Verify it returns JSON error response

175

1

    let body = axum::body::to_bytes(response.into_body(), usize::MAX)

176

1

        .await

177

1

        .unwrap();

178

1

    let body_str = String::from_utf8(body.to_vec()).unwrap();

179

1

    let json_response: serde_json::Value =

180

1

        serde_json::from_str(&body_str).expect("Response should be valid JSON");

181

182

    // Verify error structure

183

1

    assert_eq!(json_response["status"], "fail");

184

1

    assert!(json_response["message"].is_string());

185

1

186

187

#[tokio::test]

188

1

async fn test_account_create_with_parent_id() {

189

1

    let app_state = create_test_app_state().await;

190

1

    let mock_user = create_mock_user();

191

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

192

193

1

    let app = Router::new()

194

1

        .route(

195

1

            "/account/create/submit",

196

1

            post(web::pages::account::create::submit::create_account),

197

198

1

        .layer(axum::middleware::from_fn_with_state(

199

1

            app_state.clone(),

200

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

201

1

                let jwt_auth = jwt_auth.clone();

202

1

                async move {

203

1

                    req.extensions_mut().insert(jwt_auth);

204

1

                    next.run(req).await

205

1

206

1

},

207

))

208

1

        .with_state(app_state.clone());

209

210

1

    let account_data = json!({

211

1

        "name": "Child Account",

212

1

        "parent_id": "650e8400-e29b-41d4-a716-446655440001"

213

});

214

215

1

    let response = app

216

1

        .oneshot(

217

1

            Request::builder()

218

1

                .method("POST")

219

1

                .uri("/account/create/submit")

220

1

                .header("content-type", "application/json")

221

1

                .body(Body::from(account_data.to_string()))

222

1

                .unwrap(),

223

1

224

1

        .await

225

1

        .unwrap();

226

227

    // This tests that parent_id is properly handled

228

    // Even if it fails due to DB issues, it should not be a parsing error

229

1

    assert!(

230

1

        response.status().is_success() || response.status().is_server_error(),

231

1

        "Expected success or server error, got: {}",

232

1

        response.status()

233

1

);

234

1

235

236

#[tokio::test]

237

1

async fn test_account_create_invalid_parent_id() {

238

1

    let app_state = create_test_app_state().await;

239

1

    let mock_user = create_mock_user();

240

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

241

242

1

    let app = Router::new()

243

1

        .route(

244

1

            "/account/create/submit",

245

1

            post(web::pages::account::create::submit::create_account),

246

247

1

        .layer(axum::middleware::from_fn_with_state(

248

1

            app_state.clone(),

249

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

250

1

                let jwt_auth = jwt_auth.clone();

251

1

                async move {

252

1

                    req.extensions_mut().insert(jwt_auth);

253

1

                    next.run(req).await

254

1

255

1

},

256

))

257

1

        .with_state(app_state.clone());

258

259

1

    let account_data = json!({

260

1

        "name": "Test Account",

261

1

        "parent_id": "invalid_parent_uuid"

262

});

263

264

1

    let response = app

265

1

        .oneshot(

266

1

            Request::builder()

267

1

                .method("POST")

268

1

                .uri("/account/create/submit")

269

1

                .header("content-type", "application/json")

270

1

                .body(Body::from(account_data.to_string()))

271

1

                .unwrap(),

272

1

273

1

        .await

274

1

        .unwrap();

275

276

    // Should return 400 for invalid parent UUID format

277

1

    assert_eq!(response.status(), StatusCode::BAD_REQUEST);

278

279

    // Verify it returns JSON error response

280

1

    let body = axum::body::to_bytes(response.into_body(), usize::MAX)

281

1

        .await

282

1

        .unwrap();

283

1

    let body_str = String::from_utf8(body.to_vec()).unwrap();

284

1

    let json_response: serde_json::Value =

285

1

        serde_json::from_str(&body_str).expect("Response should be valid JSON");

286

287

    // Verify error structure

288

1

    assert_eq!(json_response["status"], "fail");

289

1

    assert!(json_response["message"].is_string());

290

1

291

292

// Tests for ListAccounts functionality in web handlers

293

294

#[tokio::test]

295

1

async fn test_account_table_without_auth() {

296

1

    let app_state = create_test_app_state().await;

297

1

    let app = Router::new()

298

1

        .route(

299

1

            "/account/table",

300

1

            get(web::pages::account::list::account_table),

301

302

1

        .with_state(app_state);

303

304

1

    let response = app

305

1

        .oneshot(

306

1

            Request::builder()

307

1

                .method("GET")

308

1

                .uri("/account/table")

309

1

                .body(Body::empty())

310

1

                .unwrap(),

311

1

312

1

        .await

313

1

        .unwrap();

314

315

    // Should fail without authentication

316

1

    assert!(response.status().is_client_error() || response.status().is_server_error());

317

1

318

319

#[tokio::test]

320

1

async fn test_account_table_with_mock_auth() {

321

1

    let app_state = create_test_app_state().await;

322

1

    let mock_user = create_mock_user();

323

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

324

325

1

    let app = Router::new()

326

1

        .route(

327

1

            "/account/table",

328

1

            get(web::pages::account::list::account_table),

329

330

1

        .layer(axum::middleware::from_fn_with_state(

331

1

            app_state.clone(),

332

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

333

1

                let jwt_auth = jwt_auth.clone();

334

1

                async move {

335

1

                    req.extensions_mut().insert(jwt_auth);

336

1

                    next.run(req).await

337

1

338

1

},

339

))

340

1

        .with_state(app_state.clone());

341

342

1

    let response = app

343

1

        .oneshot(

344

1

            Request::builder()

345

1

                .method("GET")

346

1

                .uri("/account/table")

347

1

                .body(Body::empty())

348

1

                .unwrap(),

349

1

350

1

        .await

351

1

        .unwrap();

352

353

    // Should succeed with auth (even if DB is empty, should return empty HTML table)

354

    // We expect either success (200) or server error (500) due to missing DB

355

    // but NOT client error (400) which would indicate API issues

356

1

    assert!(

357

1

        response.status().is_success() || response.status().is_server_error(),

358

        "Expected success or server error, got: {}",

359

        response.status()

360

);

361

362

    // Verify it returns HTML content (not JSON)

363

1

    if let Some(content_type) = response.headers().get("content-type") {

364

1

        let content_type_str = content_type.to_str().unwrap_or("");

365

1

        assert!(

366

1

            content_type_str.contains("text/html") || content_type_str.is_empty(),

367

1

            "Expected HTML content type, got: {content_type_str}"

368

1

);

369

1

370

1

371

372

#[tokio::test]

373

1

async fn test_account_tree_with_mock_auth() {

374

1

    let app_state = create_test_app_state().await;

375

1

    let mock_user = create_mock_user();

376

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

377

378

1

    let app = Router::new()

379

1

        .route(

380

1

            "/account/tree",

381

1

            get(web::pages::account::manage::account_tree),

382

383

1

        .layer(axum::middleware::from_fn_with_state(

384

1

            app_state.clone(),

385

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

386

1

                let jwt_auth = jwt_auth.clone();

387

1

                async move {

388

1

                    req.extensions_mut().insert(jwt_auth);

389

1

                    next.run(req).await

390

1

391

1

},

392

))

393

1

        .with_state(app_state.clone());

394

395

1

    let response = app

396

1

        .oneshot(

397

1

            Request::builder()

398

1

                .method("GET")

399

1

                .uri("/account/tree")

400

1

                .header(header::ACCEPT, "application/json")

401

1

                .body(Body::empty())

402

1

                .unwrap(),

403

1

404

1

        .await

405

1

        .unwrap();

406

407

1

    assert!(

408

1

        response.status().is_success() || response.status().is_server_error(),

409

1

        "Expected success or server error, got: {}",

410

1

        response.status()

411

1

);

412

1

413

414

#[tokio::test]

415

1

async fn test_account_manage_details_invalid_id() {

416

1

    let app_state = create_test_app_state().await;

417

1

    let mock_user = create_mock_user();

418

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

419

420

1

    let app = Router::new()

421

1

        .route(

422

1

            "/account/manage/details",

423

1

            get(web::pages::account::manage::account_manage_details),

424

425

1

        .layer(axum::middleware::from_fn_with_state(

426

1

            app_state.clone(),

427

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

428

1

                let jwt_auth = jwt_auth.clone();

429

1

                async move {

430

1

                    req.extensions_mut().insert(jwt_auth);

431

1

                    next.run(req).await

432

1

433

1

},

434

))

435

1

        .with_state(app_state.clone());

436

437

1

    let response = app

438

1

        .oneshot(

439

1

            Request::builder()

440

1

                .method("GET")

441

1

                .uri("/account/manage/details?account=not-a-uuid")

442

1

                .header(header::ACCEPT, "application/json")

443

1

                .body(Body::empty())

444

1

                .unwrap(),

445

1

446

1

        .await

447

1

        .unwrap();

448

449

1

    assert!(response.status().is_client_error());

450

1

451

452

#[tokio::test]

453

1

async fn test_account_manage_set_tag_empty_fields() {

454

1

    let app_state = create_test_app_state().await;

455

1

    let mock_user = create_mock_user();

456

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

457

458

1

    let app = Router::new()

459

1

        .route(

460

1

            "/account/manage/tag",

461

1

            post(web::pages::account::manage::account_manage_set_tag),

462

463

1

        .layer(axum::middleware::from_fn_with_state(

464

1

            app_state.clone(),

465

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

466

1

                let jwt_auth = jwt_auth.clone();

467

1

                async move {

468

1

                    req.extensions_mut().insert(jwt_auth);

469

1

                    next.run(req).await

470

1

471

1

},

472

))

473

1

        .with_state(app_state.clone());

474

475

1

    let payload = json!({

476

1

        "account_id": "550e8400-e29b-41d4-a716-446655440000",

477

1

        "tag_name": "",

478

1

        "tag_value": "",

479

1

        "description": ""

480

});

481

482

1

    let response = app

483

1

        .oneshot(

484

1

            Request::builder()

485

1

                .method("POST")

486

1

                .uri("/account/manage/tag")

487

1

                .header("content-type", "application/json")

488

1

                .body(Body::from(payload.to_string()))

489

1

                .unwrap(),

490

1

491

1

        .await

492

1

        .unwrap();

493

494

1

    assert_eq!(response.status(), StatusCode::BAD_REQUEST);

495

1

496

497

#[tokio::test]

498

1

async fn test_account_manage_set_tag_with_mock_auth() {

499

1

    let app_state = create_test_app_state().await;

500

1

    let mock_user = create_mock_user();

501

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

502

503

1

    let app = Router::new()

504

1

        .route(

505

1

            "/account/manage/tag",

506

1

            post(web::pages::account::manage::account_manage_set_tag),

507

508

1

        .layer(axum::middleware::from_fn_with_state(

509

1

            app_state.clone(),

510

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

511

1

                let jwt_auth = jwt_auth.clone();

512

1

                async move {

513

1

                    req.extensions_mut().insert(jwt_auth);

514

1

                    next.run(req).await

515

1

516

1

},

517

))

518

1

        .with_state(app_state.clone());

519

520

1

    let payload = json!({

521

1

        "account_id": "550e8400-e29b-41d4-a716-446655440000",

522

1

        "tag_name": "name",

523

1

        "tag_value": "Renamed Account",

524

1

        "description": null

525

});

526

527

1

    let response = app

528

1

        .oneshot(

529

1

            Request::builder()

530

1

                .method("POST")

531

1

                .uri("/account/manage/tag")

532

1

                .header("content-type", "application/json")

533

1

                .body(Body::from(payload.to_string()))

534

1

                .unwrap(),

535

1

536

1

        .await

537

1

        .unwrap();

538

539

1

    assert!(

540

1

        response.status().is_success() || response.status().is_server_error(),

541

1

        "Expected success or server error, got: {}",

542

1

        response.status()

543

1

);

544

1

545

546

#[tokio::test]

547

1

async fn test_account_table_json_response() {

548

1

    let app_state = create_test_app_state().await;

549

1

    let mock_user = create_mock_user();

550

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

551

552

1

    let app = Router::new()

553

1

        .route(

554

1

            "/account/table",

555

1

            get(web::pages::account::list::account_table),

556

557

1

        .layer(axum::middleware::from_fn_with_state(

558

1

            app_state.clone(),

559

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

560

1

                let jwt_auth = jwt_auth.clone();

561

1

                async move {

562

1

                    req.extensions_mut().insert(jwt_auth);

563

1

                    next.run(req).await

564

1

565

1

},

566

))

567

1

        .with_state(app_state.clone());

568

569

1

    let response = app

570

1

        .oneshot(

571

1

            Request::builder()

572

1

                .method("GET")

573

1

                .uri("/account/table")

574

1

                .header(header::ACCEPT, "application/json")

575

1

                .body(Body::empty())

576

1

                .unwrap(),

577

1

578

1

        .await

579

1

        .unwrap();

580

581

    // Should handle JSON requests appropriately

582

1

    assert!(

583

1

        response.status().is_success() || response.status().is_server_error(),

584

        "Expected success or server error, got: {}",

585

        response.status()

586

);

587

588

    // If successful, should return JSON

589

1

    if response.status().is_success()

590

1

        && let Some(content_type) = response.headers().get("content-type")

591

1

592

1

        let content_type_str = content_type.to_str().unwrap_or("");

593

1

        assert!(

594

1

            content_type_str.contains("application/json"),

595

1

            "Expected JSON content type for JSON request, got: {content_type_str}"

596

1

);

597

1

598

1

599

600

#[tokio::test]

601

1

async fn test_account_search_without_auth() {

602

1

    let app_state = create_test_app_state().await;

603

1

    let app = Router::new()

604

1

        .route(

605

1

            "/account/search",

606

1

            post(web::pages::account::search::search_accounts),

607

608

1

        .with_state(app_state);

609

610

1

    let search_data = json!({

611

1

        "parent-search": "test"

612

});

613

614

1

    let response = app

615

1

        .oneshot(

616

1

            Request::builder()

617

1

                .method("POST")

618

1

                .uri("/account/search")

619

1

                .header("content-type", "application/json")

620

1

                .body(Body::from(search_data.to_string()))

621

1

                .unwrap(),

622

1

623

1

        .await

624

1

        .unwrap();

625

626

    // Should fail without authentication

627

1

    assert!(response.status().is_client_error() || response.status().is_server_error());

628

1

629

630

#[tokio::test]

631

1

async fn test_account_search_with_mock_auth() {

632

1

    let app_state = create_test_app_state().await;

633

1

    let mock_user = create_mock_user();

634

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

635

636

1

    let app = Router::new()

637

1

        .route(

638

1

            "/account/search",

639

1

            post(web::pages::account::search::search_accounts),

640

641

1

        .layer(axum::middleware::from_fn_with_state(

642

1

            app_state.clone(),

643

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

644

1

                let jwt_auth = jwt_auth.clone();

645

1

                async move {

646

1

                    req.extensions_mut().insert(jwt_auth);

647

1

                    next.run(req).await

648

1

649

1

},

650

))

651

1

        .with_state(app_state.clone());

652

653

1

    let search_data = json!({

654

1

        "parent-search": "test"

655

});

656

657

1

    let response = app

658

1

        .oneshot(

659

1

            Request::builder()

660

1

                .method("POST")

661

1

                .uri("/account/search")

662

1

                .header("content-type", "application/json")

663

1

                .body(Body::from(search_data.to_string()))

664

1

                .unwrap(),

665

1

666

1

        .await

667

1

        .unwrap();

668

669

    // Should succeed with auth and return HTML search results

670

1

    assert!(

671

1

        response.status().is_success() || response.status().is_server_error(),

672

        "Expected success or server error, got: {}",

673

        response.status()

674

);

675

676

    // Should return HTML content

677

1

    if let Some(content_type) = response.headers().get("content-type") {

678

1

        let content_type_str = content_type.to_str().unwrap_or("");

679

1

        assert!(

680

1

            content_type_str.contains("text/html") || content_type_str.is_empty(),

681

1

            "Expected HTML content type, got: {content_type_str}"

682

1

);

683

1

684

1

685

686

#[tokio::test]

687

1

async fn test_validate_from_account_without_auth() {

688

1

    let app_state = create_test_app_state().await;

689

1

    let app = Router::new()

690

1

        .route(

691

1

            "/transaction/validate/from-account",

692

1

            post(web::pages::transaction::validate::validate_from_account_html),

693

694

1

        .with_state(app_state);

695

696

1

    let validation_data = json!({

697

1

        "from_account": "550e8400-e29b-41d4-a716-446655440000"

698

});

699

700

1

    let response = app

701

1

        .oneshot(

702

1

            Request::builder()

703

1

                .method("POST")

704

1

                .uri("/transaction/validate/from-account")

705

1

                .header("content-type", "application/json")

706

1

                .body(Body::from(validation_data.to_string()))

707

1

                .unwrap(),

708

1

709

1

        .await

710

1

        .unwrap();

711

712

    // Should fail without authentication

713

1

    assert!(response.status().is_client_error() || response.status().is_server_error());

714

1

715

716

#[tokio::test]

717

1

async fn test_validate_from_account_with_mock_auth() {

718

1

    let app_state = create_test_app_state().await;

719

1

    let mock_user = create_mock_user();

720

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

721

722

1

    let app = Router::new()

723

1

        .route(

724

1

            "/transaction/validate/from-account",

725

1

            post(web::pages::transaction::validate::validate_from_account_html),

726

727

1

        .layer(axum::middleware::from_fn_with_state(

728

1

            app_state.clone(),

729

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

730

1

                let jwt_auth = jwt_auth.clone();

731

1

                async move {

732

1

                    req.extensions_mut().insert(jwt_auth);

733

1

                    next.run(req).await

734

1

735

1

},

736

))

737

1

        .with_state(app_state.clone());

738

739

1

    let validation_data = json!({

740

1

        "from_account": "550e8400-e29b-41d4-a716-446655440000"

741

});

742

743

1

    let response = app

744

1

        .oneshot(

745

1

            Request::builder()

746

1

                .method("POST")

747

1

                .uri("/transaction/validate/from-account")

748

1

                .header("content-type", "application/json")

749

1

                .body(Body::from(validation_data.to_string()))

750

1

                .unwrap(),

751

1

752

1

        .await

753

1

        .unwrap();

754

755

    // Should succeed with auth - either success or server error (due to DB)

756

1

    assert!(

757

1

        response.status().is_success() || response.status().is_server_error(),

758

        "Expected success or server error, got: {}",

759

        response.status()

760

);

761

762

    // Should return HTML validation feedback

763

1

    if let Some(content_type) = response.headers().get("content-type") {

764

1

        let content_type_str = content_type.to_str().unwrap_or("");

765

1

        assert!(

766

1

            content_type_str.contains("text/html") || content_type_str.is_empty(),

767

1

            "Expected HTML content type, got: {content_type_str}"

768

1

);

769

1

770

1

771

772

#[tokio::test]

773

1

async fn test_validate_from_account_invalid_uuid_format() {

774

1

    let app_state = create_test_app_state().await;

775

1

    let mock_user = create_mock_user();

776

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

777

778

1

    let app = Router::new()

779

1

        .route(

780

1

            "/transaction/validate/from-account",

781

1

            post(web::pages::transaction::validate::validate_from_account_html),

782

783

1

        .layer(axum::middleware::from_fn_with_state(

784

1

            app_state.clone(),

785

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

786

1

                let jwt_auth = jwt_auth.clone();

787

1

                async move {

788

1

                    req.extensions_mut().insert(jwt_auth);

789

1

                    next.run(req).await

790

1

791

1

},

792

))

793

1

        .with_state(app_state.clone());

794

795

1

    let validation_data = json!({

796

1

        "from_account": "invalid-uuid-format"

797

});

798

799

1

    let response = app

800

1

        .oneshot(

801

1

            Request::builder()

802

1

                .method("POST")

803

1

                .uri("/transaction/validate/from-account")

804

1

                .header("content-type", "application/json")

805

1

                .body(Body::from(validation_data.to_string()))

806

1

                .unwrap(),

807

1

808

1

        .await

809

1

        .unwrap();

810

811

    // Should succeed and return validation error HTML

812

1

    assert!(

813

1

        response.status().is_success() || response.status().is_server_error(),

814

        "Expected success or server error, got: {}",

815

        response.status()

816

);

817

818

    // Should return HTML validation feedback

819

1

    if response.status().is_success() {

820

1

        let body = axum::body::to_bytes(response.into_body(), usize::MAX)

821

1

            .await

822

1

            .unwrap();

823

1

        let body_str = String::from_utf8(body.to_vec()).unwrap();

824

1

825

1

        // Should contain some validation feedback HTML

826

1

        assert!(

827

1

            body_str.contains("Invalid")

828

1

                || body_str.contains("error")

829

1

                || body_str.contains("validation"),

830

1

            "Expected validation error content in response body"

831

1

);

832

1

833

1

834

835

#[tokio::test]

836

1

async fn test_validate_to_account_with_mock_auth() {

837

1

    let app_state = create_test_app_state().await;

838

1

    let mock_user = create_mock_user();

839

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

840

841

1

    let app = Router::new()

842

1

        .route(

843

1

            "/transaction/validate/to-account",

844

1

            post(web::pages::transaction::validate::validate_to_account_html),

845

846

1

        .layer(axum::middleware::from_fn_with_state(

847

1

            app_state.clone(),

848

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

849

1

                let jwt_auth = jwt_auth.clone();

850

1

                async move {

851

1

                    req.extensions_mut().insert(jwt_auth);

852

1

                    next.run(req).await

853

1

854

1

},

855

))

856

1

        .with_state(app_state.clone());

857

858

1

    let validation_data = json!({

859

1

        "to_account": "550e8400-e29b-41d4-a716-446655440000"

860

});

861

862

1

    let response = app

863

1

        .oneshot(

864

1

            Request::builder()

865

1

                .method("POST")

866

1

                .uri("/transaction/validate/to-account")

867

1

                .header("content-type", "application/json")

868

1

                .body(Body::from(validation_data.to_string()))

869

1

                .unwrap(),

870

1

871

1

        .await

872

1

        .unwrap();

873

874

    // Should succeed with auth

875

1

    assert!(

876

1

        response.status().is_success() || response.status().is_server_error(),

877

        "Expected success or server error, got: {}",

878

        response.status()

879

);

880

881

    // Should return HTML validation feedback

882

1

    if let Some(content_type) = response.headers().get("content-type") {

883

1

        let content_type_str = content_type.to_str().unwrap_or("");

884

1

        assert!(

885

1

            content_type_str.contains("text/html") || content_type_str.is_empty(),

886

1

            "Expected HTML content type, got: {content_type_str}"

887

1

);

888

1

889

1

890

891

// ListSplits integration tests (via account balance functionality)

892

893

#[tokio::test]

894

1

async fn test_list_splits_in_account_balance_without_auth() {

895

1

    let app_state = create_test_app_state().await;

896

1

    let app = Router::new()

897

1

        .route(

898

1

            "/account/table",

899

1

            get(web::pages::account::list::account_table),

900

901

1

        .with_state(app_state);

902

903

1

    let response = app

904

1

        .oneshot(

905

1

            Request::builder()

906

1

                .method("GET")

907

1

                .uri("/account/table")

908

1

                .body(Body::empty())

909

1

                .unwrap(),

910

1

911

1

        .await

912

1

        .unwrap();

913

914

    // Should fail without authentication - expecting 401 or 500

915

1

    assert!(response.status().is_client_error() || response.status().is_server_error());

916

1

917

918

#[tokio::test]

919

1

async fn test_list_splits_in_account_balance_with_auth() {

920

1

    let app_state = create_test_app_state().await;

921

1

    let mock_user = create_mock_user();

922

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

923

924

1

    let app = Router::new()

925

1

        .route(

926

1

            "/account/table",

927

1

            get(web::pages::account::list::account_table),

928

929

1

        .layer(axum::middleware::from_fn_with_state(

930

1

            app_state.clone(),

931

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

932

1

                let jwt_auth = jwt_auth.clone();

933

1

                async move {

934

1

                    req.extensions_mut().insert(jwt_auth);

935

1

                    next.run(req).await

936

1

937

1

},

938

))

939

1

        .with_state(app_state.clone());

940

941

1

    let response = app

942

1

        .oneshot(

943

1

            Request::builder()

944

1

                .method("GET")

945

1

                .uri("/account/table")

946

1

                .body(Body::empty())

947

1

                .unwrap(),

948

1

949

1

        .await

950

1

        .unwrap();

951

952

    // This test verifies that ListSplits integration works in account balance calculation

953

    // Even if it fails due to DB issues, it should not be a parsing error

954

    // We expect either success (200) or a server error (500) due to missing DB

955

    // but NOT a client error (400) which would indicate API issues

956

1

    assert!(

957

1

        response.status().is_success() || response.status().is_server_error(),

958

        "Expected success or server error, got: {}",

959

        response.status()

960

);

961

962

    // If we get a response, verify it has proper content type

963

1

    if let Some(content_type) = response.headers().get("content-type") {

964

1

        let content_type_str = content_type.to_str().unwrap_or("");

965

1

        // Should be HTML for the account table template

966

1

        assert!(

967

1

            content_type_str.contains("text/html"),

968

1

            "Unexpected content type: {content_type_str}"

969

1

);

970

1

971

1

972

973

#[tokio::test]

974

1

async fn test_list_splits_in_transaction_table() {

975

1

    let app_state = create_test_app_state().await;

976

1

    let mock_user = create_mock_user();

977

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

978

979

1

    let app = Router::new()

980

1

        .route(

981

1

            "/transaction/table",

982

1

            get(web::pages::transaction::list::transaction_table),

983

984

1

        .layer(axum::middleware::from_fn_with_state(

985

1

            app_state.clone(),

986

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

987

1

                let jwt_auth = jwt_auth.clone();

988

1

                async move {

989

1

                    req.extensions_mut().insert(jwt_auth);

990

1

                    next.run(req).await

991

1

992

1

},

993

))

994

1

        .with_state(app_state.clone());

995

996

1

    let response = app

997

1

        .oneshot(

998

1

            Request::builder()

999

1

                .method("GET")

1000

1

                .uri("/transaction/table")

1001

1

                .body(Body::empty())

1002

1

                .unwrap(),

1003

1

1004

1

        .await

1005

1

        .unwrap();

1006

1007

    // This test verifies that ListSplits integration works in transaction display

1008

    // The transaction_table handler uses ListSplits to get splits for each transaction

1009

1

    assert!(

1010

1

        response.status().is_success() || response.status().is_server_error(),

1011

1

        "Expected success or server error, got: {}",

1012

1

        response.status()

1013

1

);

1014

1

1015

1016

#[tokio::test]

1017

1

async fn test_list_splits_htmx_integration() {

1018

1

    let app_state = create_test_app_state().await;

1019

1

    let mock_user = create_mock_user();

1020

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

1021

1022

1

    let app = Router::new()

1023

1

        .route(

1024

1

            "/account/table",

1025

1

            get(web::pages::account::list::account_table),

1026

1027

1

        .layer(axum::middleware::from_fn_with_state(

1028

1

            app_state.clone(),

1029

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

1030

1

                let jwt_auth = jwt_auth.clone();

1031

1

                async move {

1032

1

                    req.extensions_mut().insert(jwt_auth);

1033

1

                    next.run(req).await

1034

1

1035

1

},

1036

))

1037

1

        .with_state(app_state.clone());

1038

1039

    // Test with HTMX header (common in web usage where ListSplits is used for balance calculations)

1040

1

    let response = app

1041

1

        .oneshot(

1042

1

            Request::builder()

1043

1

                .method("GET")

1044

1

                .uri("/account/table")

1045

1

                .header("HX-Request", "true")

1046

1

                .body(Body::empty())

1047

1

                .unwrap(),

1048

1

1049

1

        .await

1050

1

        .unwrap();

1051

1052

    // Should succeed - the ListSplits integration for balance calculation should work

1053

1

    assert!(

1054

1

        response.status().is_success() || response.status().is_server_error(),

1055

1

        "Expected success or server error, got: {}",

1056

1

        response.status()

1057

1

);

1058

1

1059

1060

/// Test multi-currency account balance functionality in the web endpoint

1061

/// This tests the same scenario as the server test but through the web API

1062

#[tokio::test]

1063

1

async fn test_account_table_multi_currency_balance_json() {

1064

1

    let app_state = create_test_app_state().await;

1065

1

    let mock_user = create_mock_user();

1066

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

1067

1068

1

    let app = Router::new()

1069

1

        .route(

1070

1

            "/account/table",

1071

1

            get(web::pages::account::list::account_table),

1072

1073

1

        .layer(axum::middleware::from_fn_with_state(

1074

1

            app_state.clone(),

1075

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

1076

1

                let jwt_auth = jwt_auth.clone();

1077

1

                async move {

1078

1

                    req.extensions_mut().insert(jwt_auth);

1079

1

                    next.run(req).await

1080

1

1081

1

},

1082

))

1083

1

        .with_state(app_state.clone());

1084

1085

    // Request JSON response specifically

1086

1

    let response = app

1087

1

        .oneshot(

1088

1

            Request::builder()

1089

1

                .method("GET")

1090

1

                .uri("/account/table")

1091

1

                .header(header::ACCEPT, "application/json")

1092

1

                .body(Body::empty())

1093

1

                .unwrap(),

1094

1

1095

1

        .await

1096

1

        .unwrap();

1097

1098

    // Should succeed with auth (will likely be server error due to no DB, but structure should be right)

1099

1

    assert!(

1100

1

        response.status().is_success() || response.status().is_server_error(),

1101

        "Expected success or server error, got: {}",

1102

        response.status()

1103

);

1104

1105

    // If successful, verify the JSON structure includes balance and currency fields

1106

1

    if response.status().is_success() {

1107

1

        // Verify content type

1108

1

        if let Some(content_type) = response.headers().get("content-type") {

1109

1

            let content_type_str = content_type.to_str().unwrap_or("");

1110

1

            assert!(

1111

1

                content_type_str.contains("application/json"),

1112

1

                "Expected JSON content type, got: {content_type_str}"

1113

1

);

1114

1

1115

1

1116

1

        // Parse response body

1117

1

        let body = axum::body::to_bytes(response.into_body(), usize::MAX)

1118

            .await

1119

1

            .unwrap();

1120

1

        let body_str = String::from_utf8(body.to_vec()).unwrap();

1121

1

1122

1

        // Verify it's valid JSON (even if empty array)

1123

1

        let json_response: Value =

1124

1

            serde_json::from_str(&body_str).expect("Response should be valid JSON");

1125

1

1126

1

        // Should be an array of account objects

1127

1

        assert!(

1128

1

            json_response.is_array(),

1129

1

            "Response should be an array of accounts"

1130

1

);

1131

1

1132

1

        // If there are accounts in the response, verify they have the expected structure

1133

1

        if let Some(accounts) = json_response.as_array() {

1134

1

            for account in accounts {

1135

1

                // Each account should have these fields for multi-currency balance functionality

1136

1

                assert!(account.get("id").is_some(), "Account should have id field");

1137

1

                assert!(

1138

1

                    account.get("name").is_some(),

1139

1

                    "Account should have name field"

1140

1

);

1141

1

                assert!(

1142

1

                    account.get("balance").is_some(),

1143

1

                    "Account should have balance field"

1144

1

);

1145

1

                assert!(

1146

1

                    account.get("currency").is_some(),

1147

1

                    "Account should have currency field"

1148

1

);

1149

1

                assert!(

1150

1

                    account.get("currency_sym").is_some(),

1151

1

                    "Account should have currency_sym field"

1152

1

);

1153

1

1154

1

                // Verify balance is a string (rational number as string)

1155

1

                if let Some(balance) = account.get("balance") {

1156

1

                    assert!(

1157

1

                        balance.is_string(),

1158

1

                        "Balance should be a string representation of rational number"

1159

1

);

1160

1

1161

1

1162

1

                // Verify currency fields are strings

1163

1

                if let Some(currency) = account.get("currency") {

1164

1

                    assert!(currency.is_string(), "Currency should be a string");

1165

1

1166

1

                if let Some(currency_sym) = account.get("currency_sym") {

1167

1

                    assert!(

1168

1

                        currency_sym.is_string(),

1169

1

                        "Currency symbol should be a string"

1170

1

);

1171

1

1172

1

1173

1

1174

1

1175

1

1176

1177

/// Test that account list endpoint handles mixed currency accounts correctly

1178

/// This specifically tests the `get_balance` function behavior with multi-currency error handling

1179

#[tokio::test]

1180

1

async fn test_account_table_mixed_currency_error_handling() {

1181

1

    let app_state = create_test_app_state().await;

1182

1

    let mock_user = create_mock_user();

1183

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

1184

1185

1

    let app = Router::new()

1186

1

        .route(

1187

1

            "/account/table",

1188

1

            get(web::pages::account::list::account_table),

1189

1190

1

        .layer(axum::middleware::from_fn_with_state(

1191

1

            app_state.clone(),

1192

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

1193

1

                let jwt_auth = jwt_auth.clone();

1194

1

                async move {

1195

1

                    req.extensions_mut().insert(jwt_auth);

1196

1

                    next.run(req).await

1197

1

1198

1

},

1199

))

1200

1

        .with_state(app_state.clone());

1201

1202

1

    let response = app

1203

1

        .oneshot(

1204

1

            Request::builder()

1205

1

                .method("GET")

1206

1

                .uri("/account/table")

1207

1

                .header(header::ACCEPT, "application/json")

1208

1

                .body(Body::empty())

1209

1

                .unwrap(),

1210

1

1211

1

        .await

1212

1

        .unwrap();

1213

1214

    // This test verifies that the get_balance function properly handles:

1215

    // 1. Mixed currency accounts (returns error without commodity_id)

1216

    // 2. Proper fallback to GetAccountCommodities and get_latest_split_commodity

1217

    // 3. Balance calculation with specific commodity_id

1218

    // 4. Returns zero balance on any error (as per implementation)

1219

1220

    // Even with DB errors, the endpoint should handle the multi-currency logic gracefully

1221

1

    assert!(

1222

1

        response.status().is_success() || response.status().is_server_error(),

1223

        "Multi-currency error handling should not cause client errors, got: {}",

1224

        response.status()

1225

);

1226

1227

    // If successful, the response should still be valid JSON structure

1228

1

    if response.status().is_success() {

1229

1

        let body = axum::body::to_bytes(response.into_body(), usize::MAX)

1230

            .await

1231

1

            .unwrap();

1232

1

        let body_str = String::from_utf8(body.to_vec()).unwrap();

1233

1

1234

1

        let json_response: Value =

1235

1

            serde_json::from_str(&body_str).expect("Multi-currency response should be valid JSON");

1236

1

1237

1

        // Should be an array (empty is fine for this test)

1238

1

        assert!(

1239

1

            json_response.is_array(),

1240

1

            "Multi-currency response should be array format"

1241

1

);

1242

1

1243

1

1244

1245

/// Test that account list JSON response matches the WASM autocomplete expected format

1246

/// The WASM `AccountSuggestion` expects: id (String), name (String), currency (Option<String>)

1247

#[tokio::test]

1248

1

async fn test_account_table_json_autocomplete_format() {

1249

1

    let app_state = create_test_app_state().await;

1250

1

    let mock_user = create_mock_user();

1251

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

1252

1253

1

    let app = Router::new()

1254

1

        .route(

1255

1

            "/account/table",

1256

1

            get(web::pages::account::list::account_table),

1257

1258

1

        .layer(axum::middleware::from_fn_with_state(

1259

1

            app_state.clone(),

1260

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

1261

1

                let jwt_auth = jwt_auth.clone();

1262

1

                async move {

1263

1

                    req.extensions_mut().insert(jwt_auth);

1264

1

                    next.run(req).await

1265

1

1266

1

},

1267

))

1268

1

        .with_state(app_state.clone());

1269

1270

1

    let response = app

1271

1

        .oneshot(

1272

1

            Request::builder()

1273

1

                .method("GET")

1274

1

                .uri("/account/table")

1275

1

                .header(header::ACCEPT, "application/json")

1276

1

                .body(Body::empty())

1277

1

                .unwrap(),

1278

1

1279

1

        .await

1280

1

        .unwrap();

1281

1282

    // Verify proper response

1283

1

    assert!(

1284

1

        response.status().is_success() || response.status().is_server_error(),

1285

        "Expected success or server error, got: {}",

1286

        response.status()

1287

);

1288

1289

1

    if response.status().is_success() {

1290

1

        // Verify JSON content type

1291

1

        if let Some(content_type) = response.headers().get("content-type") {

1292

1

            let content_type_str = content_type.to_str().unwrap_or("");

1293

1

            assert!(

1294

1

                content_type_str.contains("application/json"),

1295

1

                "Expected JSON content type for autocomplete, got: {content_type_str}"

1296

1

);

1297

1

1298

1

1299

1

        let body = axum::body::to_bytes(response.into_body(), usize::MAX)

1300

            .await

1301

1

            .unwrap();

1302

1

        let body_str = String::from_utf8(body.to_vec()).unwrap();

1303

1

1304

1

        let json_response: Value =

1305

1

            serde_json::from_str(&body_str).expect("Response should be valid JSON");

1306

1

1307

1

        // Should be an array

1308

1

        assert!(

1309

1

            json_response.is_array(),

1310

1

            "Response should be an array for autocomplete"

1311

1

);

1312

1

1313

1

        // If accounts exist, verify they have the required fields for WASM autocomplete

1314

1

        if let Some(accounts) = json_response.as_array() {

1315

1

            for account in accounts {

1316

1

                // Required fields for AccountSuggestion

1317

1

                assert!(

1318

1

                    account.get("id").is_some(),

1319

1

                    "Account must have 'id' field for autocomplete"

1320

1

);

1321

1

                assert!(

1322

1

                    account.get("name").is_some(),

1323

1

                    "Account must have 'name' field for autocomplete"

1324

1

);

1325

1

                // currency is optional but field should exist

1326

1

                assert!(

1327

1

                    account.get("currency").is_some(),

1328

1

                    "Account must have 'currency' field (can be null) for autocomplete"

1329

1

);

1330

1

1331

1

                // Verify id is a string (UUID format)

1332

1

                if let Some(id) = account.get("id") {

1333

1

                    assert!(id.is_string(), "Account id must be a string");

1334

1

1335

1

1336

1

                // Verify name is a string

1337

1

                if let Some(name) = account.get("name") {

1338

1

                    assert!(name.is_string(), "Account name must be a string");

1339

1

1340

1

1341

1

                // Verify currency is null or string

1342

1

                if let Some(currency) = account.get("currency") {

1343

1

                    assert!(

1344

1

                        currency.is_null() || currency.is_string(),

1345

1

                        "Account currency must be null or string"

1346

1

);

1347

1

1348

1

1349

1

1350

1

1351

1

1352

1353

/// Test account list endpoint currency field mappings

1354

/// Verifies the currency field logic (single, mixed, none, unknown)

1355

#[tokio::test]

1356

1

async fn test_account_table_currency_field_logic() {

1357

1

    let app_state = create_test_app_state().await;

1358

1

    let mock_user = create_mock_user();

1359

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

1360

1361

1

    let app = Router::new()

1362

1

        .route(

1363

1

            "/account/table",

1364

1

            get(web::pages::account::list::account_table),

1365

1366

1

        .layer(axum::middleware::from_fn_with_state(

1367

1

            app_state.clone(),

1368

1

            move |mut req: axum::http::Request<Body>, next: axum::middleware::Next| {

1369

1

                let jwt_auth = jwt_auth.clone();

1370

1

                async move {

1371

1

                    req.extensions_mut().insert(jwt_auth);

1372

1

                    next.run(req).await

1373

1

1374

1

},

1375

))

1376

1

        .with_state(app_state.clone());

1377

1378

1

    let response = app

1379

1

        .oneshot(

1380

1

            Request::builder()

1381

1

                .method("GET")

1382

1

                .uri("/account/table")

1383

1

                .header(header::ACCEPT, "application/json")

1384

1

                .body(Body::empty())

1385

1

                .unwrap(),

1386

1

1387

1

        .await

1388

1

        .unwrap();

1389

1390

    // This test validates that the currency field mapping logic works:

1391

    // - 0 commodities: "No transaction yet" / "NONE"

1392

    // - 1 commodity: commodity name / symbol

1393

    // - Multiple commodities: latest split's commodity name / symbol

1394

    // - Error case: "unknown" / "UNK"

1395

1396

1

    assert!(

1397

1

        response.status().is_success() || response.status().is_server_error(),

1398

        "Currency field logic should handle all cases, got: {}",

1399

        response.status()

1400

);

1401

1402

1

    if response.status().is_success() {

1403

1

        let body = axum::body::to_bytes(response.into_body(), usize::MAX)

1404

            .await

1405

1

            .unwrap();

1406

1

        let body_str = String::from_utf8(body.to_vec()).unwrap();

1407

1

1408

1

        let json_response: Value =

1409

1

            serde_json::from_str(&body_str).expect("Currency field response should be valid JSON");

1410

1

1411

1

        assert!(

1412

1

            json_response.is_array(),

1413

1

            "Currency response should be array format"

1414

1

);

1415

1

1416

1

        // If accounts exist, verify currency field values are valid

1417

1

        if let Some(accounts) = json_response.as_array() {

1418

1

            for account in accounts {

1419

1

                if let (Some(currency), Some(currency_sym)) = (

1420

1

                    account.get("currency").and_then(|v| v.as_str()),

1421

1

                    account.get("currency_sym").and_then(|v| v.as_str()),

1422

1

) {

1423

1

                    // Valid currency field values based on implementation

1424

1

                    let valid_currencies = ["No transaction yet", "unknown"];

1425

1

                    let valid_symbols = ["NONE", "UNK"];

1426

1

1427

1

                    // Allow any actual commodity names/symbols too (can be anything)

1428

1

                    assert!(

1429

1

                        valid_currencies.contains(&currency) || !currency.is_empty(), // Or any actual commodity name

1430

1

                        "Invalid currency field value: {currency}"

1431

1

);

1432

1

1433

1

                    assert!(

1434

1

                        valid_symbols.contains(&currency_sym) || !currency_sym.is_empty(), // Or any actual commodity symbol

1435

1

                        "Invalid currency symbol value: {currency_sym}"

1436

1

);

1437

1

1438

1

1439

1

1440

1

1441

1