246 lines
8.5 KiB
Rust
246 lines
8.5 KiB
Rust
use sha2::{Digest, Sha256};
|
|
use std::collections::HashMap;
|
|
use std::fs;
|
|
use std::path::PathBuf;
|
|
use std::time::{Duration, Instant};
|
|
use tokio::net::TcpListener;
|
|
use tokio::time::sleep;
|
|
|
|
use bzod::analytics::AnalyticsQueue;
|
|
use bzod::config::Config;
|
|
use bzod::db::Db;
|
|
use bzod::state::AppState;
|
|
use bzod::web::create_router;
|
|
|
|
fn compute_sha256(value: &str) -> String {
|
|
let mut hasher = Sha256::new();
|
|
hasher.update(value.as_bytes());
|
|
hex::encode(hasher.finalize())
|
|
}
|
|
|
|
fn create_temp_config(temp_dir: PathBuf) -> Config {
|
|
let mut config = Config::load();
|
|
config.data_dir = temp_dir.clone();
|
|
config.backup_dir = temp_dir.clone();
|
|
config.admin_username = "admin".to_string();
|
|
config.base_url = Some("http://localhost:8080".to_string());
|
|
config.cookie_secure = false;
|
|
config.bootstrap_password_sha256 = compute_sha256("bootstrap-secret");
|
|
config
|
|
}
|
|
|
|
fn extract_csrf_token(html: &str) -> Option<String> {
|
|
let marker = "name=\"csrf_token\" value=\"";
|
|
if let Some(pos) = html.find(marker) {
|
|
let start = pos + marker.len();
|
|
if let Some(end) = html[start..].find('"') {
|
|
return Some(html[start..start + end].to_string());
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_upgrade_from_v0_4_0() {
|
|
// Create a temporary directory for the legacy v0.4.0 data
|
|
let temp_dir = std::env::temp_dir().join(format!("bzod_upgrade_test_{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&temp_dir).unwrap();
|
|
|
|
let legacy_admin_path = temp_dir.join("admin.db");
|
|
let legacy_system_path = temp_dir.join("system.db");
|
|
let legacy_content_path = temp_dir.join("content.db");
|
|
let legacy_analytics_path = temp_dir.join("analytics.db");
|
|
|
|
// Initialize legacy databases with their respective version 1 schemas and seed data
|
|
{
|
|
// 1. admin.db
|
|
let mut admin_conn = rusqlite::Connection::open(&legacy_admin_path).unwrap();
|
|
bzod::db::migrations::run_migrations(
|
|
&mut admin_conn,
|
|
"admin",
|
|
bzod::db::migrations::ADMIN_MIGRATIONS,
|
|
None,
|
|
)
|
|
.unwrap();
|
|
// Seed legacy admin user
|
|
let legacy_admin_hash = bzod::auth::hash_password("legacy-admin-pass").unwrap();
|
|
bzod::db::admin::create_user(&admin_conn, "admin", &legacy_admin_hash).unwrap();
|
|
|
|
// 2. system.db
|
|
let mut system_conn = rusqlite::Connection::open(&legacy_system_path).unwrap();
|
|
bzod::db::migrations::run_migrations(
|
|
&mut system_conn,
|
|
"system",
|
|
bzod::db::migrations::SYSTEM_MIGRATIONS,
|
|
None,
|
|
)
|
|
.unwrap();
|
|
|
|
// 3. content.db
|
|
let mut content_conn = rusqlite::Connection::open(&legacy_content_path).unwrap();
|
|
bzod::db::migrations::run_migrations(
|
|
&mut content_conn,
|
|
"content",
|
|
bzod::db::migrations::CONTENT_MIGRATIONS,
|
|
None,
|
|
)
|
|
.unwrap();
|
|
// Seed legacy url
|
|
let url = bzod::db::content::create_url_extended(
|
|
&content_conn,
|
|
"!legacy-link",
|
|
"https://example.com/legacy-redirect-target",
|
|
Some("Legacy URL"),
|
|
Some("A link from v0.4.0"),
|
|
&[],
|
|
None,
|
|
None,
|
|
None,
|
|
)
|
|
.unwrap();
|
|
|
|
// 4. analytics.db
|
|
let mut analytics_conn = rusqlite::Connection::open(&legacy_analytics_path).unwrap();
|
|
bzod::db::migrations::run_migrations(
|
|
&mut analytics_conn,
|
|
"analytics",
|
|
bzod::db::migrations::ANALYTICS_MIGRATIONS,
|
|
None,
|
|
)
|
|
.unwrap();
|
|
// Seed legacy visit record matching the seeded legacy url id
|
|
let timestamp = chrono::Utc::now().to_rfc3339();
|
|
analytics_conn
|
|
.execute(
|
|
"INSERT INTO visits (id, target_type, target_id, timestamp, ip_address, user_agent, referer, accept_language, country, status_code, owner_user_id)
|
|
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11);",
|
|
rusqlite::params![
|
|
"legacy-visit-id-123",
|
|
"url",
|
|
url.id,
|
|
timestamp,
|
|
"1.1.1.1",
|
|
"LegacyBrowser/1.0",
|
|
"https://referrer-channel.com",
|
|
"en-US",
|
|
"US",
|
|
302,
|
|
1i64 // user ID 1
|
|
],
|
|
)
|
|
.unwrap();
|
|
}
|
|
|
|
// Now start the application setup which should trigger migrations/upgrade
|
|
let config = create_temp_config(temp_dir.clone());
|
|
let db = Db::init(&config).expect("Db::init failed to upgrade v0.4.0 database directory");
|
|
|
|
// Verify file layout was reorganized
|
|
assert!(!legacy_admin_path.exists());
|
|
assert!(!legacy_content_path.exists());
|
|
assert!(!legacy_analytics_path.exists());
|
|
assert!(!legacy_system_path.exists());
|
|
|
|
assert!(temp_dir.join("admin/admin.db").exists());
|
|
assert!(temp_dir.join("admin/system.db").exists());
|
|
assert!(temp_dir.join("admin/users.db").exists());
|
|
assert!(temp_dir.join("users/1/content.db").exists());
|
|
assert!(temp_dir.join("users/1/analytics.db").exists());
|
|
|
|
// Spawn server
|
|
let (tx, rx) = tokio::sync::watch::channel(false);
|
|
Box::leak(Box::new(tx));
|
|
let (queue, _) = AnalyticsQueue::new(db.clone(), 10, rx);
|
|
let state = AppState {
|
|
admin_db: db.admin.clone(),
|
|
content_db: db.content.clone(),
|
|
analytics_db: db.analytics.clone(),
|
|
system_db: db.system.clone(),
|
|
users_db: db.users.clone(),
|
|
user_dbs: std::sync::Arc::new(std::sync::Mutex::new(HashMap::new())),
|
|
db: db.clone(),
|
|
config,
|
|
analytics_queue: queue,
|
|
start_time: Instant::now(),
|
|
};
|
|
|
|
let router = create_router(state.clone());
|
|
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
|
|
let addr = listener.local_addr().unwrap();
|
|
let base_url = format!("http://{}", addr);
|
|
|
|
let _server_handle = tokio::spawn(async move {
|
|
axum::serve(listener, router).await.unwrap();
|
|
});
|
|
|
|
let client = reqwest::Client::builder()
|
|
.cookie_store(true)
|
|
.redirect(reqwest::redirect::Policy::none())
|
|
.build()
|
|
.unwrap();
|
|
|
|
// 1. Admin login works (Bootstrap path because we migrated)
|
|
let login_url = format!("{}/admin/login", base_url);
|
|
let res = client.get(&login_url).send().await.unwrap();
|
|
let html = res.text().await.unwrap();
|
|
let csrf_token =
|
|
extract_csrf_token(&html).expect("Failed to extract CSRF token from login page");
|
|
|
|
let mut params = HashMap::new();
|
|
params.insert("username", "admin");
|
|
params.insert("password", "bootstrap-secret");
|
|
params.insert("csrf_token", &csrf_token);
|
|
|
|
let login_res = client.post(&login_url).form(¶ms).send().await.unwrap();
|
|
assert!(login_res.status().is_redirection());
|
|
assert_eq!(
|
|
login_res
|
|
.headers()
|
|
.get("location")
|
|
.unwrap()
|
|
.to_str()
|
|
.unwrap(),
|
|
"/admin/dashboard"
|
|
);
|
|
|
|
// 2. Existing links redirect correctly
|
|
let redirect_url = format!("{}/!legacy-link", base_url);
|
|
let redirect_res = client.get(&redirect_url).send().await.unwrap();
|
|
let res_headers = redirect_res.headers();
|
|
assert!(res_headers.get("location").is_some());
|
|
assert_eq!(
|
|
res_headers.get("location").unwrap().to_str().unwrap(),
|
|
"https://example.com/legacy-redirect-target"
|
|
);
|
|
|
|
// Sleep 3 seconds for the analytics queue to process and flush to database
|
|
sleep(Duration::from_millis(3000)).await;
|
|
|
|
// 3. Analytics preserved and new click recorded
|
|
let user_dbs = state.get_user_dbs(1).unwrap();
|
|
let analytics_conn = user_dbs.analytics.lock().unwrap();
|
|
|
|
// Check count of visits for the legacy link (should be 2: 1 legacy + 1 new redirect click)
|
|
let visit_count: i64 = analytics_conn
|
|
.query_row(
|
|
"SELECT COUNT(*) FROM visits WHERE target_type = 'url';",
|
|
[],
|
|
|row| row.get(0),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(visit_count, 2);
|
|
|
|
// Verify the details of the legacy visit are preserved
|
|
let legacy_visit_exists: bool = analytics_conn
|
|
.query_row(
|
|
"SELECT EXISTS(SELECT 1 FROM visits WHERE id = 'legacy-visit-id-123' AND user_agent = 'LegacyBrowser/1.0' AND referer = 'https://referrer-channel.com');",
|
|
[],
|
|
|row| row.get(0),
|
|
)
|
|
.unwrap();
|
|
assert!(legacy_visit_exists);
|
|
|
|
// Clean up temporary folder
|
|
let _ = fs::remove_dir_all(&temp_dir);
|
|
}
|