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_expires_in: "15m".to_string(),

15

6

        access_token_max_age: 900,

16

6

        refresh_token_expires_in: "60m".to_string(),

17

6

        refresh_token_max_age: 3600,

18

6

        ssh: web::config::SshConnectInfo {

19

6

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

20

6

            port: 2222,

21

6

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

22

6

},

23

6

};

24

25

6

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

26

27

6

    Arc::new(AppState {

28

6

        conf,

29

6

        redis_client,

30

6

        frac: 42,

31

6

        user: Mutex::new(Some(User {

32

6

            id: Uuid::new_v4(),

33

6

            name: "Test User".to_string(),

34

6

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

35

6

            password: "hashed".to_string(),

36

6

            role: "user".to_string(),

37

6

            photo: String::new(),

38

6

            verified: true,

39

6

            database: "testdb".to_string(),

40

6

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

41

6

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

42

6

        })),

43

6

})

44

6

45

46

#[tokio::test]

47

1

async fn test_index_handler_logged_out() {

48

1

    let app_state = create_test_app_state();

49

1

    let cookie_jar = CookieJar::new();

50

51

1

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

52

1

    let response = response.into_response();

53

54

1

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

55

1

56

57

#[tokio::test]

58

1

async fn test_index_handler_returns_correct_fraction() {

59

1

    let app_state = create_test_app_state();

60

1

    let cookie_jar = CookieJar::new();

61

62

    // Verify the fraction value is passed correctly

63

1

    assert_eq!(app_state.frac, 42);

64

65

1

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

66

    // Template should receive fraction: 42

67

1

68

69

#[tokio::test]

70

1

async fn test_index_handler_user_data() {

71

1

    let app_state = create_test_app_state();

72

1

    let cookie_jar = CookieJar::new();

73

74

    // Verify user data is accessible

75

1

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

76

1

    assert!(user_guard.is_some());

77

1

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

78

1

    drop(user_guard);

79

80

1

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

81

1

82

83

#[tokio::test]

84

1

async fn test_file_table_handler() {

85

1

    let app_state = create_test_app_state();

86

87

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

88

1

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

89

90

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

91

1

    match result {

92

1

        Ok(response) => {

93

1

            let response = response.into_response();

94

1

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

95

1

96

1

        Err(status) => {

97

1

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

98

1

            assert!(matches!(

99

1

                status,

100

1

                StatusCode::INTERNAL_SERVER_ERROR | StatusCode::SERVICE_UNAVAILABLE

101

1

));

102

1

103

1

104

1

105

106

#[tokio::test]

107

1

async fn test_register_handler() {

108

1

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

109

1

    let response = response.into_response();

110

111

1

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

112

1

113

114

#[tokio::test]

115

1

async fn test_login_handler() {

116

1

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

117

1

    let response = response.into_response();

118

119

1

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

120

1

121

122

#[tokio::test]

123

1

async fn test_app_state_fraction_value() {

124

1

    let app_state = create_test_app_state();

125

126

    // Verify the test value in AppState

127

1

    assert_eq!(app_state.frac, 42);

128

1

129

130

#[tokio::test]

131

1

async fn test_app_state_user_value() {

132

1

    let app_state = create_test_app_state();

133

134

1

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

135

1

    assert!(user_guard.is_some());

136

137

1

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

138

1

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

139

1

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

140

1

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

141

1

    assert!(user.verified);

142

1