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_table_json_response() {

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/table",

381

1

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

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/table")

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

    // Should handle JSON requests appropriately

408

1

    assert!(

409

1

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

410

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

411

        response.status()

412

);

413

414

    // If successful, should return JSON

415

1

    if response.status().is_success()

416

1

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

417

1

418

1

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

419

1

        assert!(

420

1

            content_type_str.contains("application/json"),

421

1

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

422

1

);

423

1

424

1

425

426

#[tokio::test]

427

1

async fn test_account_search_without_auth() {

428

1

    let app_state = create_test_app_state().await;

429

1

    let app = Router::new()

430

1

        .route(

431

1

            "/account/search",

432

1

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

433

434

1

        .with_state(app_state);

435

436

1

    let search_data = json!({

437

1

        "parent-search": "test"

438

});

439

440

1

    let response = app

441

1

        .oneshot(

442

1

            Request::builder()

443

1

                .method("POST")

444

1

                .uri("/account/search")

445

1

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

446

1

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

447

1

                .unwrap(),

448

1

449

1

        .await

450

1

        .unwrap();

451

452

    // Should fail without authentication

453

1

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

454

1

455

456

#[tokio::test]

457

1

async fn test_account_search_with_mock_auth() {

458

1

    let app_state = create_test_app_state().await;

459

1

    let mock_user = create_mock_user();

460

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

461

462

1

    let app = Router::new()

463

1

        .route(

464

1

            "/account/search",

465

1

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

466

467

1

        .layer(axum::middleware::from_fn_with_state(

468

1

            app_state.clone(),

469

1

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

470

1

                let jwt_auth = jwt_auth.clone();

471

1

                async move {

472

1

                    req.extensions_mut().insert(jwt_auth);

473

1

                    next.run(req).await

474

1

475

1

},

476

))

477

1

        .with_state(app_state.clone());

478

479

1

    let search_data = json!({

480

1

        "parent-search": "test"

481

});

482

483

1

    let response = app

484

1

        .oneshot(

485

1

            Request::builder()

486

1

                .method("POST")

487

1

                .uri("/account/search")

488

1

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

489

1

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

490

1

                .unwrap(),

491

1

492

1

        .await

493

1

        .unwrap();

494

495

    // Should succeed with auth and return HTML search results

496

1

    assert!(

497

1

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

498

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

499

        response.status()

500

);

501

502

    // Should return HTML content

503

1

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

504

1

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

505

1

        assert!(

506

1

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

507

1

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

508

1

);

509

1

510

1

511

512

#[tokio::test]

513

1

async fn test_validate_from_account_without_auth() {

514

1

    let app_state = create_test_app_state().await;

515

1

    let app = Router::new()

516

1

        .route(

517

1

            "/transaction/validate/from-account",

518

1

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

519

520

1

        .with_state(app_state);

521

522

1

    let validation_data = json!({

523

1

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

524

});

525

526

1

    let response = app

527

1

        .oneshot(

528

1

            Request::builder()

529

1

                .method("POST")

530

1

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

531

1

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

532

1

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

533

1

                .unwrap(),

534

1

535

1

        .await

536

1

        .unwrap();

537

538

    // Should fail without authentication

539

1

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

540

1

541

542

#[tokio::test]

543

1

async fn test_validate_from_account_with_mock_auth() {

544

1

    let app_state = create_test_app_state().await;

545

1

    let mock_user = create_mock_user();

546

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

547

548

1

    let app = Router::new()

549

1

        .route(

550

1

            "/transaction/validate/from-account",

551

1

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

552

553

1

        .layer(axum::middleware::from_fn_with_state(

554

1

            app_state.clone(),

555

1

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

556

1

                let jwt_auth = jwt_auth.clone();

557

1

                async move {

558

1

                    req.extensions_mut().insert(jwt_auth);

559

1

                    next.run(req).await

560

1

561

1

},

562

))

563

1

        .with_state(app_state.clone());

564

565

1

    let validation_data = json!({

566

1

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

567

});

568

569

1

    let response = app

570

1

        .oneshot(

571

1

            Request::builder()

572

1

                .method("POST")

573

1

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

574

1

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

575

1

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

576

1

                .unwrap(),

577

1

578

1

        .await

579

1

        .unwrap();

580

581

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

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

    // Should return HTML validation feedback

589

1

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

590

1

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

591

1

        assert!(

592

1

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

593

1

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

594

1

);

595

1

596

1

597

598

#[tokio::test]

599

1

async fn test_validate_from_account_invalid_uuid_format() {

600

1

    let app_state = create_test_app_state().await;

601

1

    let mock_user = create_mock_user();

602

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

603

604

1

    let app = Router::new()

605

1

        .route(

606

1

            "/transaction/validate/from-account",

607

1

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

608

609

1

        .layer(axum::middleware::from_fn_with_state(

610

1

            app_state.clone(),

611

1

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

612

1

                let jwt_auth = jwt_auth.clone();

613

1

                async move {

614

1

                    req.extensions_mut().insert(jwt_auth);

615

1

                    next.run(req).await

616

1

617

1

},

618

))

619

1

        .with_state(app_state.clone());

620

621

1

    let validation_data = json!({

622

1

        "from_account": "invalid-uuid-format"

623

});

624

625

1

    let response = app

626

1

        .oneshot(

627

1

            Request::builder()

628

1

                .method("POST")

629

1

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

630

1

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

631

1

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

632

1

                .unwrap(),

633

1

634

1

        .await

635

1

        .unwrap();

636

637

    // Should succeed and return validation error HTML

638

1

    assert!(

639

1

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

640

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

641

        response.status()

642

);

643

644

    // Should return HTML validation feedback

645

1

    if response.status().is_success() {

646

1

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

647

1

            .await

648

1

            .unwrap();

649

1

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

650

1

651

1

        // Should contain some validation feedback HTML

652

1

        assert!(

653

1

            body_str.contains("Invalid")

654

1

                || body_str.contains("error")

655

1

                || body_str.contains("validation"),

656

1

            "Expected validation error content in response body"

657

1

);

658

1

659

1

660

661

#[tokio::test]

662

1

async fn test_validate_to_account_with_mock_auth() {

663

1

    let app_state = create_test_app_state().await;

664

1

    let mock_user = create_mock_user();

665

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

666

667

1

    let app = Router::new()

668

1

        .route(

669

1

            "/transaction/validate/to-account",

670

1

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

671

672

1

        .layer(axum::middleware::from_fn_with_state(

673

1

            app_state.clone(),

674

1

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

675

1

                let jwt_auth = jwt_auth.clone();

676

1

                async move {

677

1

                    req.extensions_mut().insert(jwt_auth);

678

1

                    next.run(req).await

679

1

680

1

},

681

))

682

1

        .with_state(app_state.clone());

683

684

1

    let validation_data = json!({

685

1

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

686

});

687

688

1

    let response = app

689

1

        .oneshot(

690

1

            Request::builder()

691

1

                .method("POST")

692

1

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

693

1

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

694

1

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

695

1

                .unwrap(),

696

1

697

1

        .await

698

1

        .unwrap();

699

700

    // Should succeed with auth

701

1

    assert!(

702

1

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

703

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

704

        response.status()

705

);

706

707

    // Should return HTML validation feedback

708

1

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

709

1

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

710

1

        assert!(

711

1

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

712

1

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

713

1

);

714

1

715

1

716

717

// ListSplits integration tests (via account balance functionality)

718

719

#[tokio::test]

720

1

async fn test_list_splits_in_account_balance_without_auth() {

721

1

    let app_state = create_test_app_state().await;

722

1

    let app = Router::new()

723

1

        .route(

724

1

            "/account/table",

725

1

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

726

727

1

        .with_state(app_state);

728

729

1

    let response = app

730

1

        .oneshot(

731

1

            Request::builder()

732

1

                .method("GET")

733

1

                .uri("/account/table")

734

1

                .body(Body::empty())

735

1

                .unwrap(),

736

1

737

1

        .await

738

1

        .unwrap();

739

740

    // Should fail without authentication - expecting 401 or 500

741

1

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

742

1

743

744

#[tokio::test]

745

1

async fn test_list_splits_in_account_balance_with_auth() {

746

1

    let app_state = create_test_app_state().await;

747

1

    let mock_user = create_mock_user();

748

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

749

750

1

    let app = Router::new()

751

1

        .route(

752

1

            "/account/table",

753

1

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

754

755

1

        .layer(axum::middleware::from_fn_with_state(

756

1

            app_state.clone(),

757

1

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

758

1

                let jwt_auth = jwt_auth.clone();

759

1

                async move {

760

1

                    req.extensions_mut().insert(jwt_auth);

761

1

                    next.run(req).await

762

1

763

1

},

764

))

765

1

        .with_state(app_state.clone());

766

767

1

    let response = app

768

1

        .oneshot(

769

1

            Request::builder()

770

1

                .method("GET")

771

1

                .uri("/account/table")

772

1

                .body(Body::empty())

773

1

                .unwrap(),

774

1

775

1

        .await

776

1

        .unwrap();

777

778

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

779

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

780

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

781

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

782

1

    assert!(

783

1

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

784

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

785

        response.status()

786

);

787

788

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

789

1

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

790

1

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

791

1

        // Should be HTML for the account table template

792

1

        assert!(

793

1

            content_type_str.contains("text/html"),

794

1

            "Unexpected content type: {content_type_str}"

795

1

);

796

1

797

1

798

799

#[tokio::test]

800

1

async fn test_list_splits_in_transaction_table() {

801

1

    let app_state = create_test_app_state().await;

802

1

    let mock_user = create_mock_user();

803

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

804

805

1

    let app = Router::new()

806

1

        .route(

807

1

            "/transaction/table",

808

1

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

809

810

1

        .layer(axum::middleware::from_fn_with_state(

811

1

            app_state.clone(),

812

1

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

813

1

                let jwt_auth = jwt_auth.clone();

814

1

                async move {

815

1

                    req.extensions_mut().insert(jwt_auth);

816

1

                    next.run(req).await

817

1

818

1

},

819

))

820

1

        .with_state(app_state.clone());

821

822

1

    let response = app

823

1

        .oneshot(

824

1

            Request::builder()

825

1

                .method("GET")

826

1

                .uri("/transaction/table")

827

1

                .body(Body::empty())

828

1

                .unwrap(),

829

1

830

1

        .await

831

1

        .unwrap();

832

833

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

834

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

835

1

    assert!(

836

1

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

837

1

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

838

1

        response.status()

839

1

);

840

1

841

842

#[tokio::test]

843

1

async fn test_list_splits_htmx_integration() {

844

1

    let app_state = create_test_app_state().await;

845

1

    let mock_user = create_mock_user();

846

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

847

848

1

    let app = Router::new()

849

1

        .route(

850

1

            "/account/table",

851

1

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

852

853

1

        .layer(axum::middleware::from_fn_with_state(

854

1

            app_state.clone(),

855

1

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

856

1

                let jwt_auth = jwt_auth.clone();

857

1

                async move {

858

1

                    req.extensions_mut().insert(jwt_auth);

859

1

                    next.run(req).await

860

1

861

1

},

862

))

863

1

        .with_state(app_state.clone());

864

865

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

866

1

    let response = app

867

1

        .oneshot(

868

1

            Request::builder()

869

1

                .method("GET")

870

1

                .uri("/account/table")

871

1

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

872

1

                .body(Body::empty())

873

1

                .unwrap(),

874

1

875

1

        .await

876

1

        .unwrap();

877

878

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

879

1

    assert!(

880

1

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

881

1

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

882

1

        response.status()

883

1

);

884

1

885

886

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

887

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

888

#[tokio::test]

889

1

async fn test_account_table_multi_currency_balance_json() {

890

1

    let app_state = create_test_app_state().await;

891

1

    let mock_user = create_mock_user();

892

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

893

894

1

    let app = Router::new()

895

1

        .route(

896

1

            "/account/table",

897

1

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

898

899

1

        .layer(axum::middleware::from_fn_with_state(

900

1

            app_state.clone(),

901

1

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

902

1

                let jwt_auth = jwt_auth.clone();

903

1

                async move {

904

1

                    req.extensions_mut().insert(jwt_auth);

905

1

                    next.run(req).await

906

1

907

1

},

908

))

909

1

        .with_state(app_state.clone());

910

911

    // Request JSON response specifically

912

1

    let response = app

913

1

        .oneshot(

914

1

            Request::builder()

915

1

                .method("GET")

916

1

                .uri("/account/table")

917

1

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

918

1

                .body(Body::empty())

919

1

                .unwrap(),

920

1

921

1

        .await

922

1

        .unwrap();

923

924

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

925

1

    assert!(

926

1

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

927

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

928

        response.status()

929

);

930

931

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

932

1

    if response.status().is_success() {

933

1

        // Verify content type

934

1

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

935

1

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

936

1

            assert!(

937

1

                content_type_str.contains("application/json"),

938

1

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

939

1

);

940

1

941

1

942

1

        // Parse response body

943

1

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

944

            .await

945

1

            .unwrap();

946

1

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

947

1

948

1

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

949

1

        let json_response: Value =

950

1

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

951

1

952

1

        // Should be an array of account objects

953

1

        assert!(

954

1

            json_response.is_array(),

955

1

            "Response should be an array of accounts"

956

1

);

957

1

958

1

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

959

1

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

960

1

            for account in accounts {

961

1

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

962

1

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

963

1

                assert!(

964

1

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

965

1

                    "Account should have name field"

966

1

);

967

1

                assert!(

968

1

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

969

1

                    "Account should have balance field"

970

1

);

971

1

                assert!(

972

1

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

973

1

                    "Account should have currency field"

974

1

);

975

1

                assert!(

976

1

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

977

1

                    "Account should have currency_sym field"

978

1

);

979

1

980

1

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

981

1

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

982

1

                    assert!(

983

1

                        balance.is_string(),

984

1

                        "Balance should be a string representation of rational number"

985

1

);

986

1

987

1

988

1

                // Verify currency fields are strings

989

1

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

990

1

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

991

1

992

1

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

993

1

                    assert!(

994

1

                        currency_sym.is_string(),

995

1

                        "Currency symbol should be a string"

996

1

);

997

1

998

1

999

1

1000

1

1001

1

1002

1003

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

1004

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

1005

#[tokio::test]

1006

1

async fn test_account_table_mixed_currency_error_handling() {

1007

1

    let app_state = create_test_app_state().await;

1008

1

    let mock_user = create_mock_user();

1009

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

1010

1011

1

    let app = Router::new()

1012

1

        .route(

1013

1

            "/account/table",

1014

1

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

1015

1016

1

        .layer(axum::middleware::from_fn_with_state(

1017

1

            app_state.clone(),

1018

1

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

1019

1

                let jwt_auth = jwt_auth.clone();

1020

1

                async move {

1021

1

                    req.extensions_mut().insert(jwt_auth);

1022

1

                    next.run(req).await

1023

1

1024

1

},

1025

))

1026

1

        .with_state(app_state.clone());

1027

1028

1

    let response = app

1029

1

        .oneshot(

1030

1

            Request::builder()

1031

1

                .method("GET")

1032

1

                .uri("/account/table")

1033

1

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

1034

1

                .body(Body::empty())

1035

1

                .unwrap(),

1036

1

1037

1

        .await

1038

1

        .unwrap();

1039

1040

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

1041

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

1042

    // 2. Proper fallback to GetAccountCommodities and get_latest_split_commodity

1043

    // 3. Balance calculation with specific commodity_id

1044

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

1045

1046

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

1047

1

    assert!(

1048

1

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

1049

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

1050

        response.status()

1051

);

1052

1053

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

1054

1

    if response.status().is_success() {

1055

1

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

1056

            .await

1057

1

            .unwrap();

1058

1

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

1059

1

1060

1

        let json_response: Value =

1061

1

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

1062

1

1063

1

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

1064

1

        assert!(

1065

1

            json_response.is_array(),

1066

1

            "Multi-currency response should be array format"

1067

1

);

1068

1

1069

1

1070

1071

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

1072

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

1073

#[tokio::test]

1074

1

async fn test_account_table_json_autocomplete_format() {

1075

1

    let app_state = create_test_app_state().await;

1076

1

    let mock_user = create_mock_user();

1077

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

1078

1079

1

    let app = Router::new()

1080

1

        .route(

1081

1

            "/account/table",

1082

1

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

1083

1084

1

        .layer(axum::middleware::from_fn_with_state(

1085

1

            app_state.clone(),

1086

1

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

1087

1

                let jwt_auth = jwt_auth.clone();

1088

1

                async move {

1089

1

                    req.extensions_mut().insert(jwt_auth);

1090

1

                    next.run(req).await

1091

1

1092

1

},

1093

))

1094

1

        .with_state(app_state.clone());

1095

1096

1

    let response = app

1097

1

        .oneshot(

1098

1

            Request::builder()

1099

1

                .method("GET")

1100

1

                .uri("/account/table")

1101

1

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

1102

1

                .body(Body::empty())

1103

1

                .unwrap(),

1104

1

1105

1

        .await

1106

1

        .unwrap();

1107

1108

    // Verify proper response

1109

1

    assert!(

1110

1

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

1111

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

1112

        response.status()

1113

);

1114

1115

1

    if response.status().is_success() {

1116

1

        // Verify JSON content type

1117

1

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

1118

1

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

1119

1

            assert!(

1120

1

                content_type_str.contains("application/json"),

1121

1

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

1122

1

);

1123

1

1124

1

1125

1

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

1126

            .await

1127

1

            .unwrap();

1128

1

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

1129

1

1130

1

        let json_response: Value =

1131

1

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

1132

1

1133

1

        // Should be an array

1134

1

        assert!(

1135

1

            json_response.is_array(),

1136

1

            "Response should be an array for autocomplete"

1137

1

);

1138

1

1139

1

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

1140

1

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

1141

1

            for account in accounts {

1142

1

                // Required fields for AccountSuggestion

1143

1

                assert!(

1144

1

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

1145

1

                    "Account must have 'id' field for autocomplete"

1146

1

);

1147

1

                assert!(

1148

1

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

1149

1

                    "Account must have 'name' field for autocomplete"

1150

1

);

1151

1

                // currency is optional but field should exist

1152

1

                assert!(

1153

1

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

1154

1

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

1155

1

);

1156

1

1157

1

                // Verify id is a string (UUID format)

1158

1

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

1159

1

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

1160

1

1161

1

1162

1

                // Verify name is a string

1163

1

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

1164

1

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

1165

1

1166

1

1167

1

                // Verify currency is null or string

1168

1

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

1169

1

                    assert!(

1170

1

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

1171

1

                        "Account currency must be null or string"

1172

1

);

1173

1

1174

1

1175

1

1176

1

1177

1

1178

1179

/// Test account list endpoint currency field mappings

1180

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

1181

#[tokio::test]

1182

1

async fn test_account_table_currency_field_logic() {

1183

1

    let app_state = create_test_app_state().await;

1184

1

    let mock_user = create_mock_user();

1185

1

    let jwt_auth = create_mock_jwt_auth(mock_user);

1186

1187

1

    let app = Router::new()

1188

1

        .route(

1189

1

            "/account/table",

1190

1

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

1191

1192

1

        .layer(axum::middleware::from_fn_with_state(

1193

1

            app_state.clone(),

1194

1

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

1195

1

                let jwt_auth = jwt_auth.clone();

1196

1

                async move {

1197

1

                    req.extensions_mut().insert(jwt_auth);

1198

1

                    next.run(req).await

1199

1

1200

1

},

1201

))

1202

1

        .with_state(app_state.clone());

1203

1204

1

    let response = app

1205

1

        .oneshot(

1206

1

            Request::builder()

1207

1

                .method("GET")

1208

1

                .uri("/account/table")

1209

1

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

1210

1

                .body(Body::empty())

1211

1

                .unwrap(),

1212

1

1213

1

        .await

1214

1

        .unwrap();

1215

1216

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

1217

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

1218

    // - 1 commodity: commodity name / symbol

1219

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

1220

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

1221

1222

1

    assert!(

1223

1

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

1224

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

1225

        response.status()

1226

);

1227

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("Currency field response should be valid JSON");

1236

1

1237

1

        assert!(

1238

1

            json_response.is_array(),

1239

1

            "Currency response should be array format"

1240

1

);

1241

1

1242

1

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

1243

1

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

1244

1

            for account in accounts {

1245

1

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

1246

1

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

1247

1

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

1248

1

) {

1249

1

                    // Valid currency field values based on implementation

1250

1

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

1251

1

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

1252

1

1253

1

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

1254

1

                    assert!(

1255

1

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

1256

1

                        "Invalid currency field value: {currency}"

1257

1

);

1258

1

1259

1

                    assert!(

1260

1

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

1261

1

                        "Invalid currency symbol value: {currency_sym}"

1262

1

);

1263

1

1264

1

1265

1

1266

1

1267

1