Grcov report - test

1

use axum::{extract::State, http::StatusCode, response::IntoResponse};

2

use axum_extra::extract::CookieJar;

3

use redis::Client;

4

use std::sync::Arc;

5

use tokio::sync::Mutex;

6

use uuid::Uuid;

7

use web::{AppState, Config, User, pages};

8

9

6

fn create_test_app_state() -> Arc<AppState> {

10

6

    let conf = Config {

11

6

        site_url: "http://localhost:8080".to_string(),

12

6

        redis_url: "redis://127.0.0.1:6379".to_string(),

13

6

        client_origin: "http://localhost:3000".to_string(),

14

6

        access_token_private_key: "test_private_key".to_string(),

15

6

        access_token_public_key: "test_public_key".to_string(),

16

6

        refresh_token_private_key: "test_refresh_private".to_string(),

17

6

        refresh_token_public_key: "test_refresh_public".to_string(),

18

6

        access_token_expires_in: "15m".to_string(),

19

6

        access_token_max_age: 900,

20

6

        refresh_token_expires_in: "60m".to_string(),

21

6

        refresh_token_max_age: 3600,

22

6

};

23

24

6

    let redis_client = Client::open("redis://127.0.0.1:6379").unwrap();

25

26

6

    Arc::new(AppState {

27

6

        conf,

28

6

        redis_client,

29

6

        frac: 42,

30

6

        user: Mutex::new(Some(User {

31

6

            id: Uuid::new_v4(),

32

6

            name: "Test User".to_string(),

33

6

            email: "test@example.com".to_string(),

34

6

            password: "hashed".to_string(),

35

6

            role: "user".to_string(),

36

6

            photo: String::new(),

37

6

            verified: true,

38

6

            database: "testdb".to_string(),

39

6

            created_at: Some(chrono::Utc::now()),

40

6

            updated_at: Some(chrono::Utc::now()),

41

6

        })),

42

6

})

43

6

44

45

#[tokio::test]

46

1

async fn test_index_handler_logged_out() {

47

1

    let app_state = create_test_app_state();

48

1

    let cookie_jar = CookieJar::new();

49

50

1

    let response = pages::index(State(app_state), cookie_jar).await;

51

1

    let response = response.into_response();

52

53

1

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

54

1

55

56

#[tokio::test]

57

1

async fn test_index_handler_returns_correct_fraction() {

58

1

    let app_state = create_test_app_state();

59

1

    let cookie_jar = CookieJar::new();

60

61

    // Verify the fraction value is passed correctly

62

1

    assert_eq!(app_state.frac, 42);

63

64

1

    let _response = pages::index(State(app_state), cookie_jar).await;

65

    // Template should receive fraction: 42

66

1

67

68

#[tokio::test]

69

1

async fn test_index_handler_user_data() {

70

1

    let app_state = create_test_app_state();

71

1

    let cookie_jar = CookieJar::new();

72

73

    // Verify user data is accessible

74

1

    let user_guard = app_state.user.lock().await;

75

1

    assert!(user_guard.is_some());

76

1

    assert_eq!(user_guard.as_ref().unwrap().name, "Test User");

77

1

    drop(user_guard);

78

79

1

    let _response = pages::index(State(app_state), cookie_jar).await;

80

1

81

82

#[tokio::test]

83

1

async fn test_file_table_handler() {

84

1

    let app_state = create_test_app_state();

85

86

    // This will likely fail due to S3 dependencies, but we can test the structure

87

1

    let result = pages::file_table(State(app_state)).await;

88

89

    // Should return either Ok or Err, both are valid outcomes for this test

90

1

    match result {

91

1

        Ok(response) => {

92

1

            let response = response.into_response();

93

1

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

94

1

95

1

        Err(status) => {

96

1

            // Expected to fail in test environment due to S3 dependencies

97

1

            assert!(matches!(

98

1

                status,

99

1

                StatusCode::INTERNAL_SERVER_ERROR | StatusCode::SERVICE_UNAVAILABLE

100

1

));

101

1

102

1

103

1

104

105

#[tokio::test]

106

1

async fn test_register_handler() {

107

1

    let response = pages::register().await;

108

1

    let response = response.into_response();

109

110

1

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

111

1

112

113

#[tokio::test]

114

1

async fn test_login_handler() {

115

1

    let response = pages::login().await;

116

1

    let response = response.into_response();

117

118

1

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

119

1

120

121

#[tokio::test]

122

1

async fn test_app_state_fraction_value() {

123

1

    let app_state = create_test_app_state();

124

125

    // Verify the test value in AppState

126

1

    assert_eq!(app_state.frac, 42);

127

1

128

129

#[tokio::test]

130

1

async fn test_app_state_user_value() {

131

1

    let app_state = create_test_app_state();

132

133

1

    let user_guard = app_state.user.lock().await;

134

1

    assert!(user_guard.is_some());

135

136

1

    let user = user_guard.as_ref().unwrap();

137

1

    assert_eq!(user.name, "Test User");

138

1

    assert_eq!(user.email, "test@example.com");

139

1

    assert_eq!(user.database, "testdb");

140

1

    assert!(user.verified);

141

1