fn create_test_app_state() -> Arc<AppState> {

    let conf = Config {

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

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

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

        access_token_private_key: "test_private_key".to_string(),

        access_token_public_key: "test_public_key".to_string(),

        refresh_token_private_key: "test_refresh_private".to_string(),

        refresh_token_public_key: "test_refresh_public".to_string(),

        access_token_expires_in: "15m".to_string(),

        access_token_max_age: 900,

        refresh_token_expires_in: "60m".to_string(),

        refresh_token_max_age: 3600,

    };

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

    Arc::new(AppState {

        conf,

        redis_client,

        frac: 42,

        user: Mutex::new(Some(User {

            id: Uuid::new_v4(),

            name: "Test User".to_string(),

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

            password: "hashed".to_string(),

            role: "user".to_string(),

            photo: "".to_string(),

            verified: true,

            database: "testdb".to_string(),

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

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

        })),

    })

}

async fn test_index_handler_logged_out() {

    let app_state = create_test_app_state();

    let cookie_jar = CookieJar::new();

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

    let response = response.into_response();

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

}

async fn test_index_handler_returns_correct_fraction() {

    let app_state = create_test_app_state();

    let cookie_jar = CookieJar::new();

    assert_eq!(app_state.frac, 42);

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

}

async fn test_index_handler_user_data() {

    let app_state = create_test_app_state();

    let cookie_jar = CookieJar::new();

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

    assert!(user_guard.is_some());

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

    drop(user_guard);

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

}

async fn test_file_table_handler() {

    let app_state = create_test_app_state();

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

    match result {

        Ok(response) => {

            let response = response.into_response();

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

        }

        Err(status) => {

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

            assert!(matches!(

                status,

                StatusCode::INTERNAL_SERVER_ERROR | StatusCode::SERVICE_UNAVAILABLE

            ));

        }

    }

}

async fn test_register_handler() {

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

    let response = response.into_response();

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

}

async fn test_login_handler() {

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

    let response = response.into_response();

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

}

async fn test_app_state_fraction_value() {

    let app_state = create_test_app_state();

    assert_eq!(app_state.frac, 42);

}

async fn test_app_state_user_value() {

    let app_state = create_test_app_state();

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

    assert!(user_guard.is_some());

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

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

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

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

    assert!(user.verified);

}