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

        access_token_max_age: 900,

14

6

        refresh_token_max_age: 3600,

15

6

        ssh: web::config::SshConnectInfo {

16

6

            hostname: "ssh.example.invalid".to_string(),

17

6

            port: 2222,

18

6

            host_fingerprint: "(test)".to_string(),

19

6

},

20

6

};

21

22

6

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

23

24

6

    Arc::new(AppState {

25

6

        conf,

26

6

        redis_client,

27

6

        frac: 42,

28

6

        user: Mutex::new(Some(User {

29

6

            id: Uuid::new_v4(),

30

6

            name: "Test User".to_string(),

31

6

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

32

6

            role: "user".to_string(),

33

6

            photo: String::new(),

34

6

            verified: true,

35

6

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

36

6

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

37

6

        })),

38

6

})

39

6

40

41

#[supp_macro::shared_runtime_test]

42

1

async fn test_index_handler_logged_out() {

43

1

    let _app_state = create_test_app_state();

44

1

    let cookie_jar = CookieJar::new();

45

46

1

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

47

1

    let response = response.into_response();

48

49

1

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

50

51

52

#[supp_macro::shared_runtime_test]

53

1

async fn test_index_handler_returns_correct_fraction() {

54

1

    let app_state = create_test_app_state();

55

1

    let cookie_jar = CookieJar::new();

56

57

    // Verify the fraction value is passed correctly

58

1

    assert_eq!(app_state.frac, 42);

59

60

1

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

61

    // Template should receive fraction: 42

62

63

64

#[supp_macro::shared_runtime_test]

65

1

async fn test_index_handler_user_data() {

66

1

    let app_state = create_test_app_state();

67

1

    let cookie_jar = CookieJar::new();

68

69

    // Verify user data is accessible

70

1

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

71

1

    assert!(user_guard.is_some());

72

1

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

73

1

    drop(user_guard);

74

75

1

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

76

77

78

#[supp_macro::shared_runtime_test]

79

1

async fn test_file_table_handler() {

80

1

    let app_state = create_test_app_state();

81

82

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

83

1

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

84

85

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

86

1

    match result {

87

1

        Ok(response) => {

88

1

            let response = response.into_response();

89

1

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

90

91

        Err(status) => {

92

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

93

            assert!(matches!(

94

                status,

95

                StatusCode::INTERNAL_SERVER_ERROR | StatusCode::SERVICE_UNAVAILABLE

96

));

97

98

99

100

101

#[supp_macro::shared_runtime_test]

102

1

async fn test_register_handler() {

103

1

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

104

1

    let response = response.into_response();

105

106

1

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

107

108

109

#[supp_macro::shared_runtime_test]

110

1

async fn test_login_handler() {

111

1

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

112

1

    let response = response.into_response();

113

114

1

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

115

116

117

#[supp_macro::shared_runtime_test]

118

1

async fn test_app_state_fraction_value() {

119

1

    let app_state = create_test_app_state();

120

121

    // Verify the test value in AppState

122

1

    assert_eq!(app_state.frac, 42);

123

124

125

#[supp_macro::shared_runtime_test]

126

1

async fn test_app_state_user_value() {

127

1

    let app_state = create_test_app_state();

128

129

1

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

130

1

    assert!(user_guard.is_some());

131

132

1

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

133

1

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

134

1

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

135

1

    assert!(user.verified);

136