Grcov report - test_commodity

1

use axum::{

2

    Router,

3

    body::Body,

4

    http::{Request, StatusCode},

5

    routing::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

12

#[tokio::test]

13

3

async fn test_commodity_submit_without_auth() {

14

2

    let app_state = create_test_app_state().await;

15

2

    let app = Router::new()

16

2

        .route(

17

2

            "/commodity/create/submit",

18

2

            post(web::pages::commodity::create::submit::commodity_submit),

19

20

2

        .with_state(app_state);

21

22

2

    let commodity_data = json!({

23

2

        "fraction": "100",

24

2

        "symbol": "USD",

25

2

        "name": "US Dollar"

26

});

27

28

2

    let response = app

29

2

        .oneshot(

30

2

            Request::builder()

31

2

                .method("POST")

32

2

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

33

2

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

34

2

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

35

2

                .unwrap(),

36

2

37

2

        .await

38

2

        .unwrap();

39

40

    // Should fail without authentication - expecting 401 or 500

41

3

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

42

2

43

44

#[tokio::test]

45

3

async fn test_commodity_submit_with_invalid_json() {

46

2

    let app_state = create_test_app_state().await;

47

2

    let app = Router::new()

48

2

        .route(

49

2

            "/commodity/create/submit",

50

2

            post(web::pages::commodity::create::submit::commodity_submit),

51

52

2

        .with_state(app_state);

53

54

2

    let response = app

55

2

        .oneshot(

56

2

            Request::builder()

57

2

                .method("POST")

58

2

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

59

2

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

60

2

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

61

2

                .unwrap(),

62

2

63

2

        .await

64

2

        .unwrap();

65

66

    // Should return 400 for invalid JSON or 500 if auth fails first

67

3

    assert!(

68

3

        response.status() == StatusCode::BAD_REQUEST || response.status().is_server_error(),

69

2

        "Expected 400 or 5xx error, got: {}",

70

2

        response.status()

71

2

);

72

2

73

74

#[tokio::test]

75

3

async fn test_commodity_submit_with_mock_auth() {

76

2

    let app_state = create_test_app_state().await;

77

2

    let mock_user = create_mock_user();

78

2

    let jwt_auth = create_mock_jwt_auth(mock_user);

79

80

2

    let app = Router::new()

81

2

        .route(

82

2

            "/commodity/create/submit",

83

2

            post(web::pages::commodity::create::submit::commodity_submit),

84

85

2

        .layer(axum::middleware::from_fn_with_state(

86

2

            app_state.clone(),

87

2

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

88

2

                let jwt_auth = jwt_auth.clone();

89

2

                async move {

90

2

                    req.extensions_mut().insert(jwt_auth);

91

2

                    next.run(req).await

92

2

93

2

},

94

))

95

2

        .with_state(app_state.clone());

96

97

2

    let commodity_data = json!({

98

2

        "fraction": "100",

99

2

        "symbol": "TST",

100

2

        "name": "Test Commodity"

101

});

102

103

2

    let response = app

104

2

        .oneshot(

105

2

            Request::builder()

106

2

                .method("POST")

107

2

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

108

2

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

109

2

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

110

2

                .unwrap(),

111

2

112

2

        .await

113

2

        .unwrap();

114

115

    // This test verifies our new CreateCommodity macro integration works

116

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

117

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

118

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

119

2

    assert!(

120

2

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

121

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

122

        response.status()

123

);

124

125

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

126

3

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

127

3

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

128

2

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

129

3

        assert!(

130

3

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

131

2

            "Unexpected content type: {}",

132

2

            content_type_str

133

2

);

134

2

135

2

136

137

#[tokio::test]

138

3

async fn test_commodity_submit_invalid_fraction() {

139

2

    let app_state = create_test_app_state().await;

140

2

    let mock_user = create_mock_user();

141

2

    let jwt_auth = create_mock_jwt_auth(mock_user);

142

143

2

    let app = Router::new()

144

2

        .route(

145

2

            "/commodity/create/submit",

146

2

            post(web::pages::commodity::create::submit::commodity_submit),

147

148

2

        .layer(axum::middleware::from_fn_with_state(

149

2

            app_state.clone(),

150

2

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

151

2

                let jwt_auth = jwt_auth.clone();

152

2

                async move {

153

2

                    req.extensions_mut().insert(jwt_auth);

154

2

                    next.run(req).await

155

2

156

2

},

157

))

158

2

        .with_state(app_state.clone());

159

160

2

    let commodity_data = json!({

161

2

        "fraction": "invalid_number",

162

2

        "symbol": "TST",

163

2

        "name": "Test Commodity"

164

});

165

166

2

    let response = app

167

2

        .oneshot(

168

2

            Request::builder()

169

2

                .method("POST")

170

2

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

171

2

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

172

2

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

173

2

                .unwrap(),

174

2

175

2

        .await

176

2

        .unwrap();

177

178

    // Should return 400 for invalid fraction format

179

2

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

180

181

    // Verify it returns JSON error response

182

2

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

183

2

        .await

184

2

        .unwrap();

185

2

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

186

2

    let json_response: serde_json::Value =

187

2

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

188

189

    // Verify error structure

190

2

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

191

3

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

192

2

193

194

#[tokio::test]

195

3

async fn test_commodity_table_without_auth() {

196

2

    let app_state = create_test_app_state().await;

197

2

    let app = Router::new()

198

2

        .route(

199

2

            "/commodity/list",

200

2

            axum::routing::get(web::pages::commodity::list::commodity_table),

201

202

2

        .with_state(app_state);

203

204

2

    let response = app

205

2

        .oneshot(

206

2

            Request::builder()

207

2

                .method("GET")

208

2

                .uri("/commodity/list")

209

2

                .body(Body::empty())

210

2

                .unwrap(),

211

2

212

2

        .await

213

2

        .unwrap();

214

215

    // Should fail without authentication - expecting 401 or 500

216

3

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

217

2

218

219

#[tokio::test]

220

3

async fn test_commodity_table_with_mock_auth() {

221

2

    let app_state = create_test_app_state().await;

222

2

    let mock_user = create_mock_user();

223

2

    let jwt_auth = create_mock_jwt_auth(mock_user);

224

225

2

    let app = Router::new()

226

2

        .route(

227

2

            "/commodity/list",

228

2

            axum::routing::get(web::pages::commodity::list::commodity_table),

229

230

2

        .layer(axum::middleware::from_fn_with_state(

231

2

            app_state.clone(),

232

2

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

233

2

                let jwt_auth = jwt_auth.clone();

234

2

                async move {

235

2

                    req.extensions_mut().insert(jwt_auth);

236

2

                    next.run(req).await

237

2

238

2

},

239

))

240

2

        .with_state(app_state.clone());

241

242

2

    let response = app

243

2

        .oneshot(

244

2

            Request::builder()

245

2

                .method("GET")

246

2

                .uri("/commodity/list")

247

2

                .body(Body::empty())

248

2

                .unwrap(),

249

2

250

2

        .await

251

2

        .unwrap();

252

253

    // This test verifies our ListCommodities macro integration works

254

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

255

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

256

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

257

2

    assert!(

258

2

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

259

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

260

        response.status()

261

);

262

263

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

264

3

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

265

2

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

266

2

        // Should be HTML for the table template

267

2

        assert!(

268

2

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

269

2

            "Unexpected content type: {}",

270

2

            content_type_str

271

2

);

272

3

273

2

274

275

#[tokio::test]

276

3

async fn test_commodity_table_listing_integration() {

277

2

    let app_state = create_test_app_state().await;

278

2

    let mock_user = create_mock_user();

279

2

    let jwt_auth = create_mock_jwt_auth(mock_user);

280

281

    // Create a router with both commodity creation and listing endpoints

282

2

    let app = Router::new()

283

2

        .route(

284

2

            "/commodity/create/submit",

285

2

            axum::routing::post(web::pages::commodity::create::submit::commodity_submit),

286

287

2

        .route(

288

2

            "/commodity/list",

289

2

            axum::routing::get(web::pages::commodity::list::commodity_table),

290

291

2

        .layer(axum::middleware::from_fn_with_state(

292

2

            app_state.clone(),

293

6

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

294

6

                let jwt_auth = jwt_auth.clone();

295

6

                async move {

296

6

                    req.extensions_mut().insert(jwt_auth);

297

6

                    next.run(req).await

298

6

299

6

},

300

))

301

2

        .with_state(app_state.clone());

302

303

    // First, create some test commodities

304

2

    let usd_commodity = serde_json::json!({

305

2

        "fraction": "100",

306

2

        "symbol": "USD",

307

2

        "name": "US Dollar"

308

});

309

310

2

    let eur_commodity = serde_json::json!({

311

2

        "fraction": "100",

312

2

        "symbol": "EUR",

313

2

        "name": "Euro"

314

});

315

316

    // Create USD commodity

317

2

    let create_response = app

318

2

        .clone()

319

2

        .oneshot(

320

2

            Request::builder()

321

2

                .method("POST")

322

2

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

323

2

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

324

2

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

325

2

                .unwrap(),

326

2

327

2

        .await

328

2

        .unwrap();

329

330

    // Should succeed or fail gracefully (DB might not be available in test environment)

331

2

    assert!(

332

2

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

333

        "USD commodity creation failed with unexpected status: {}",

334

        create_response.status()

335

);

336

337

    // Create EUR commodity

338

2

    let create_response = app

339

2

        .clone()

340

2

        .oneshot(

341

2

            Request::builder()

342

2

                .method("POST")

343

2

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

344

2

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

345

2

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

346

2

                .unwrap(),

347

2

348

2

        .await

349

2

        .unwrap();

350

351

    // Should succeed or fail gracefully

352

2

    assert!(

353

2

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

354

        "EUR commodity creation failed with unexpected status: {}",

355

        create_response.status()

356

);

357

358

    // Now test the commodity listing

359

2

    let list_response = app

360

2

        .oneshot(

361

2

            Request::builder()

362

2

                .method("GET")

363

2

                .uri("/commodity/list")

364

2

                .body(Body::empty())

365

2

                .unwrap(),

366

2

367

2

        .await

368

2

        .unwrap();

369

370

    // This test verifies the complete ListCommodities integration in the web layer

371

    // It tests that the commodity_table handler correctly calls the ListCommodities command

372

    // and renders the HTML table template with the results

373

2

    assert!(

374

2

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

375

        "Expected success or server error for commodity list, got: {}",

376

        list_response.status()

377

);

378

379

    // Verify response has correct content type for HTML table

380

3

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

381

2

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

382

2

        assert!(

383

2

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

384

2

            "Expected HTML content type for commodity table, got: {}",

385

2

            content_type_str

386

2

);

387

3

388

2

389

2

    // If we get a successful response, check that it's actually HTML table content

390

3

    if list_response.status().is_success() {

391

2

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

392

1

            .await

393

2

            .unwrap();

394

2

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

395

2

396

2

        // The response should contain HTML table elements for the commodity list

397

2

        // This verifies that the ListCommodities command result is properly rendered

398

2

        assert!(

399

2

            body_str.contains("<table") || body_str.contains("commodity") || !body_str.is_empty(),

400

2

            "Expected HTML table content in commodity list response, got empty or non-HTML content"

401

2

);

402

3

403

2

404

405

#[tokio::test]

406

3

async fn test_commodity_search_without_auth() {

407

2

    let app_state = create_test_app_state().await;

408

2

    let app = Router::new()

409

2

        .route(

410

2

            "/commodity/search",

411

2

            axum::routing::post(web::pages::commodity::search::search_commodities),

412

413

2

        .with_state(app_state);

414

415

2

    let search_data = serde_json::json!({

416

2

        "commodity-search": "USD"

417

});

418

419

2

    let response = app

420

2

        .oneshot(

421

2

            Request::builder()

422

2

                .method("POST")

423

2

                .uri("/commodity/search")

424

2

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

425

2

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

426

2

                .unwrap(),

427

2

428

2

        .await

429

2

        .unwrap();

430

431

    // Should fail without authentication - expecting 401 or 500

432

3

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

433

2

434

435

#[tokio::test]

436

3

async fn test_commodity_search_with_mock_auth() {

437

2

    let app_state = create_test_app_state().await;

438

2

    let mock_user = create_mock_user();

439

2

    let jwt_auth = create_mock_jwt_auth(mock_user);

440

441

2

    let app = Router::new()

442

2

        .route(

443

2

            "/commodity/search",

444

2

            axum::routing::post(web::pages::commodity::search::search_commodities),

445

446

2

        .layer(axum::middleware::from_fn_with_state(

447

2

            app_state.clone(),

448

2

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

449

2

                let jwt_auth = jwt_auth.clone();

450

2

                async move {

451

2

                    req.extensions_mut().insert(jwt_auth);

452

2

                    next.run(req).await

453

2

454

2

},

455

))

456

2

        .with_state(app_state.clone());

457

458

2

    let search_data = serde_json::json!({

459

2

        "commodity-search": "TST"

460

});

461

462

2

    let response = app

463

2

        .oneshot(

464

2

            Request::builder()

465

2

                .method("POST")

466

2

                .uri("/commodity/search")

467

2

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

468

2

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

469

2

                .unwrap(),

470

2

471

2

        .await

472

2

        .unwrap();

473

474

    // This test verifies our ListCommodities macro integration works in search

475

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

476

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

477

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

478

2

    assert!(

479

2

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

480

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

481

        response.status()

482

);

483

484

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

485

3

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

486

3

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

487

2

        // Should be HTML for the search results template

488

3

        assert!(

489

3

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

490

2

            "Unexpected content type: {}",

491

2

            content_type_str

492

2

);

493

2

494

2

495

496

#[tokio::test]

497

3

async fn test_commodity_search_with_invalid_json() {

498

2

    let app_state = create_test_app_state().await;

499

2

    let mock_user = create_mock_user();

500

2

    let jwt_auth = create_mock_jwt_auth(mock_user);

501

502

2

    let app = Router::new()

503

2

        .route(

504

2

            "/commodity/search",

505

2

            axum::routing::post(web::pages::commodity::search::search_commodities),

506

507

2

        .layer(axum::middleware::from_fn_with_state(

508

2

            app_state.clone(),

509

2

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

510

2

                let jwt_auth = jwt_auth.clone();

511

2

                async move {

512

2

                    req.extensions_mut().insert(jwt_auth);

513

2

                    next.run(req).await

514

2

515

2

},

516

))

517

2

        .with_state(app_state.clone());

518

519

2

    let response = app

520

2

        .oneshot(

521

2

            Request::builder()

522

2

                .method("POST")

523

2

                .uri("/commodity/search")

524

2

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

525

2

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

526

2

                .unwrap(),

527

2

528

2

        .await

529

2

        .unwrap();

530

531

    // Should return 400 for invalid JSON or other error

532

3

    assert!(

533

3

        response.status() == StatusCode::BAD_REQUEST || response.status().is_server_error(),

534

2

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

535

2

        response.status()

536

2

);

537

2

538

539

#[tokio::test]

540

3

async fn test_get_commodity_account_balance_integration() {

541

2

    let app_state = create_test_app_state().await;

542

2

    let mock_user = create_mock_user();

543

2

    let jwt_auth = create_mock_jwt_auth(mock_user);

544

545

2

    let app = Router::new()

546

2

        .route(

547

2

            "/account/list",

548

2

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

549

550

2

        .layer(axum::middleware::from_fn_with_state(

551

2

            app_state.clone(),

552

2

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

553

2

                let jwt_auth = jwt_auth.clone();

554

2

                async move {

555

2

                    req.extensions_mut().insert(jwt_auth);

556

2

                    next.run(req).await

557

2

558

2

},

559

))

560

2

        .with_state(app_state.clone());

561

562

2

    let response = app

563

2

        .oneshot(

564

2

            Request::builder()

565

2

                .method("GET")

566

2

                .uri("/account/list")

567

2

                .body(Body::empty())

568

2

                .unwrap(),

569

2

570

2

        .await

571

2

        .unwrap();

572

573

    // This test verifies GetCommodity is working correctly for account balance currency display

574

    // Even with DB connection issues, it should handle the GetCommodity calls gracefully

575

3

    assert!(

576

3

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

577

2

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

578

2

        response.status()

579

2

);

580

2

581

582

#[tokio::test]

583

3

async fn test_get_commodity_transaction_currency_integration() {

584

2

    let app_state = create_test_app_state().await;

585

2

    let mock_user = create_mock_user();

586

2

    let jwt_auth = create_mock_jwt_auth(mock_user);

587

588

2

    let app = Router::new()

589

2

        .route(

590

2

            "/transaction/list",

591

2

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

592

593

2

        .layer(axum::middleware::from_fn_with_state(

594

2

            app_state.clone(),

595

2

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

596

2

                let jwt_auth = jwt_auth.clone();

597

2

                async move {

598

2

                    req.extensions_mut().insert(jwt_auth);

599

2

                    next.run(req).await

600

2

601

2

},

602

))

603

2

        .with_state(app_state.clone());

604

605

2

    let response = app

606

2

        .oneshot(

607

2

            Request::builder()

608

2

                .method("GET")

609

2

                .uri("/transaction/list")

610

2

                .body(Body::empty())

611

2

                .unwrap(),

612

2

613

2

        .await

614

2

        .unwrap();

615

616

    // This test verifies GetCommodity integration in transaction currency display

617

    // The macro-based GetCommodity should work correctly for currency symbol lookup

618

3

    assert!(

619

3

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

620

2

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

621

2

        response.status()

622

2

);

623

2

624

625

#[tokio::test]

626

3

async fn test_get_commodity_transaction_create_integration() {

627

2

    let app_state = create_test_app_state().await;

628

2

    let mock_user = create_mock_user();

629

2

    let jwt_auth = create_mock_jwt_auth(mock_user);

630

631

2

    let app = Router::new()

632

2

        .route(

633

2

            "/transaction/create/submit",

634

2

            axum::routing::post(web::pages::transaction::create::submit::transaction_submit),

635

636

2

        .layer(axum::middleware::from_fn_with_state(

637

2

            app_state.clone(),

638

2

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

639

2

                let jwt_auth = jwt_auth.clone();

640

2

                async move {

641

2

                    req.extensions_mut().insert(jwt_auth);

642

2

                    next.run(req).await

643

2

644

2

},

645

))

646

2

        .with_state(app_state.clone());

647

648

2

    let transaction_data = serde_json::json!({

649

2

        "splits": [{

650

2

            "amount": "100.00",

651

2

            "amount_converted": "100.00",

652

2

            "from_account": "00000000-0000-0000-0000-000000000001",

653

2

            "to_account": "00000000-0000-0000-0000-000000000002",

654

2

            "from_commodity": "00000000-0000-0000-0000-000000000003",

655

2

            "to_commodity": "00000000-0000-0000-0000-000000000003"

656

}],

657

2

        "note": "Test transaction",

658

2

        "date": "2024-01-01T00:00:00Z"

659

});

660

661

2

    let response = app

662

2

        .oneshot(

663

2

            Request::builder()

664

2

                .method("POST")

665

2

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

666

2

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

667

2

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

668

2

                .unwrap(),

669

2

670

2

        .await

671

2

        .unwrap();

672

673

    // This test verifies GetCommodity integration in transaction creation for commodity fraction validation

674

    // The macro-based GetCommodity should be called during transaction processing

675

3

    assert!(

676

3

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

677

2

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

678

2

        response.status()

679

2

);

680

2