Grcov report - test_general

1

use axum::{

2

    Router,

3

    body::Body,

4

    http::{Request, StatusCode},

5

    routing::get,

6

};

7

use tower::ServiceExt;

8

9

use crate::common::create_test_app_state;

10

11

// SIMPLE HANDLERS TESTS (no external dependencies)

12

13

#[tokio::test]

14

1

async fn test_get_version_handler() {

15

1

    let app = Router::new().route("/version", get(web::handler::get_version));

16

17

1

    let response = app

18

1

        .oneshot(

19

1

            Request::builder()

20

1

                .uri("/version")

21

1

                .body(Body::empty())

22

1

                .unwrap(),

23

1

24

1

        .await

25

1

        .unwrap();

26

27

1

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

28

29

1

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

30

1

        .await

31

1

        .unwrap();

32

1

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

33

34

    // Should contain some version info (git hash)

35

1

    assert!(!body_str.is_empty());

36

1

37

38

#[tokio::test]

39

1

async fn test_get_logout_link_handler() {

40

1

    let app_state = create_test_app_state().await;

41

1

    let app = Router::new()

42

1

        .route("/logout", get(web::handler::get_logout_link))

43

1

        .with_state(app_state);

44

45

1

    let response = app

46

1

        .oneshot(

47

1

            Request::builder()

48

1

                .uri("/logout")

49

1

                .body(Body::empty())

50

1

                .unwrap(),

51

1

52

1

        .await

53

1

        .unwrap();

54

55

1

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

56

57

1

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

58

1

        .await

59

1

        .unwrap();

60

1

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

61

62

    // Should contain the logout link

63

1

    assert!(body_str.contains("/api/auth/logout"));

64

1

65

66

#[tokio::test]

67

1

async fn test_handlers_return_proper_json_errors() {

68

1

    let app_state = create_test_app_state().await;

69

1

    let app = Router::new()

70

1

        .route(

71

1

            "/auth/login",

72

1

            axum::routing::post(web::handler::login_user_handler),

73

74

1

        .route(

75

1

            "/auth/register",

76

1

            axum::routing::post(web::handler::register_user_handler),

77

78

1

        .route(

79

1

            "/auth/refresh",

80

1

            axum::routing::get(web::handler::refresh_access_token_handler),

81

82

1

        .with_state(app_state);

83

84

    // Test login with invalid JSON

85

1

    let response = app

86

1

        .clone()

87

1

        .oneshot(

88

1

            Request::builder()

89

1

                .method("POST")

90

1

                .uri("/auth/login")

91

1

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

92

1

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

93

1

                .unwrap(),

94

1

95

1

        .await

96

1

        .unwrap();

97

98

1

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

99

100

    // Test register with invalid JSON

101

1

    let response = app

102

1

        .clone()

103

1

        .oneshot(

104

1

            Request::builder()

105

1

                .method("POST")

106

1

                .uri("/auth/register")

107

1

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

108

1

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

109

1

                .unwrap(),

110

1

111

1

        .await

112

1

        .unwrap();

113

114

1

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

115

116

    // Test refresh without cookie

117

1

    let response = app

118

1

        .oneshot(

119

1

            Request::builder()

120

1

                .uri("/auth/refresh")

121

1

                .body(Body::empty())

122

1

                .unwrap(),

123

1

124

1

        .await

125

1

        .unwrap();

126

127

    // May return 401 (Unauthorized) or 403 (Forbidden) depending on auth middleware

128

1

    assert!(

129

1

        response.status() == StatusCode::UNAUTHORIZED || response.status() == StatusCode::FORBIDDEN,

130

        "Expected 401 or 403, got: {}",

131

        response.status()

132

);

133

134

    // Verify it returns JSON

135

1

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

136

1

        .await

137

1

        .unwrap();

138

1

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

139

1

    let _: serde_json::Value =

140

1

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

141

1