feat: finishing of M0
This commit is contained in:
561
crates/bds-core/tests/fixture_readability.rs
Normal file
561
crates/bds-core/tests/fixture_readability.rs
Normal file
@@ -0,0 +1,561 @@
|
||||
//! Integration tests that open the real fixture DB extracted from the TypeScript bDS app
|
||||
//! and verify every table can be read correctly into Rust model structs.
|
||||
//!
|
||||
//! This validates the compatibility contract: the Rust app MUST read databases
|
||||
//! created by the TypeScript app without modification.
|
||||
|
||||
use rusqlite::{Connection, OpenFlags};
|
||||
use std::path::PathBuf;
|
||||
|
||||
fn fixture_db() -> Connection {
|
||||
let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||||
.join("../../fixtures/compatibility-projects/rfc1437-sample/bds.db");
|
||||
assert!(path.exists(), "fixture DB not found at {}", path.display());
|
||||
Connection::open_with_flags(&path, OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap()
|
||||
}
|
||||
|
||||
const PROJECT_ID: &str = "1979237c-034d-41f6-99a0-f35eb57b3f6c";
|
||||
|
||||
// ── Project ─────────────────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn read_project() {
|
||||
let conn = fixture_db();
|
||||
let (id, name, slug, data_path, is_active): (String, String, String, String, bool) = conn
|
||||
.query_row(
|
||||
"SELECT id, name, slug, data_path, is_active FROM projects WHERE id = ?1",
|
||||
[PROJECT_ID],
|
||||
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?, row.get(4)?)),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(id, PROJECT_ID);
|
||||
assert_eq!(name, "rfc1437");
|
||||
assert_eq!(slug, "rfc1437");
|
||||
assert!(data_path.contains("rfc1437.de"));
|
||||
assert!(is_active);
|
||||
}
|
||||
|
||||
// ── Posts ────────────────────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn read_published_post_has_null_content() {
|
||||
let conn = fixture_db();
|
||||
let (title, slug, status, content): (String, String, String, Option<String>) = conn
|
||||
.query_row(
|
||||
"SELECT title, slug, status, content FROM posts WHERE slug = 'esmeralda'",
|
||||
[],
|
||||
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(title, "Esmeralda");
|
||||
assert_eq!(slug, "esmeralda");
|
||||
assert_eq!(status, "published");
|
||||
assert!(content.is_none(), "published posts must have NULL content in DB");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_draft_post_has_content() {
|
||||
let conn = fixture_db();
|
||||
let (title, slug, status, content): (String, String, String, Option<String>) = conn
|
||||
.query_row(
|
||||
"SELECT title, slug, status, content FROM posts WHERE slug = 'draft-fixture-post'",
|
||||
[],
|
||||
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(title, "Draft Fixture Post");
|
||||
assert_eq!(slug, "draft-fixture-post");
|
||||
assert_eq!(status, "draft");
|
||||
assert!(content.is_some(), "draft posts must have content in DB");
|
||||
assert!(content.unwrap().contains("**body**"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_all_posts_count() {
|
||||
let conn = fixture_db();
|
||||
let count: i64 = conn
|
||||
.query_row("SELECT COUNT(*) FROM posts", [], |row| row.get(0))
|
||||
.unwrap();
|
||||
assert_eq!(count, 4); // 3 published + 1 draft
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn published_posts_have_file_paths() {
|
||||
let conn = fixture_db();
|
||||
let mut stmt = conn
|
||||
.prepare("SELECT slug, file_path FROM posts WHERE status = 'published'")
|
||||
.unwrap();
|
||||
let rows: Vec<(String, String)> = stmt
|
||||
.query_map([], |row| Ok((row.get(0)?, row.get(1)?)))
|
||||
.unwrap()
|
||||
.map(|r| r.unwrap())
|
||||
.collect();
|
||||
|
||||
assert_eq!(rows.len(), 3);
|
||||
for (slug, path) in &rows {
|
||||
assert!(!path.is_empty(), "published post '{slug}' must have a file_path");
|
||||
assert!(path.ends_with(&format!("{slug}.md")), "file_path must end with {slug}.md");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn post_tags_are_json_arrays() {
|
||||
let conn = fixture_db();
|
||||
let tags_json: Option<String> = conn
|
||||
.query_row(
|
||||
"SELECT tags FROM posts WHERE slug = 'esmeralda'",
|
||||
[],
|
||||
|row| row.get(0),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
if let Some(json) = tags_json {
|
||||
let parsed: Vec<String> = serde_json::from_str(&json).unwrap();
|
||||
assert!(!parsed.is_empty());
|
||||
}
|
||||
// tags can also be NULL — both are valid
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn post_timestamps_are_unix_integers() {
|
||||
let conn = fixture_db();
|
||||
let (created_at, updated_at): (i64, i64) = conn
|
||||
.query_row(
|
||||
"SELECT created_at, updated_at FROM posts WHERE slug = 'esmeralda'",
|
||||
[],
|
||||
|row| Ok((row.get(0)?, row.get(1)?)),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// Sanity: timestamps should be in reasonable Unix range (year 2000+)
|
||||
assert!(created_at > 946_684_800, "created_at should be after year 2000");
|
||||
assert!(updated_at > 946_684_800, "updated_at should be after year 2000");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn post_unique_constraint_on_project_slug() {
|
||||
let conn = fixture_db();
|
||||
let mut stmt = conn
|
||||
.prepare("SELECT project_id, slug, COUNT(*) FROM posts GROUP BY project_id, slug HAVING COUNT(*) > 1")
|
||||
.unwrap();
|
||||
let dupes: Vec<(String, String, i64)> = stmt
|
||||
.query_map([], |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)))
|
||||
.unwrap()
|
||||
.map(|r| r.unwrap())
|
||||
.collect();
|
||||
|
||||
assert!(dupes.is_empty(), "found duplicate (project_id, slug) pairs: {dupes:?}");
|
||||
}
|
||||
|
||||
// ── Post Translations ───────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn read_post_translations() {
|
||||
let conn = fixture_db();
|
||||
let count: i64 = conn
|
||||
.query_row("SELECT COUNT(*) FROM post_translations", [], |row| row.get(0))
|
||||
.unwrap();
|
||||
assert_eq!(count, 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn translation_references_valid_post() {
|
||||
let conn = fixture_db();
|
||||
let mut stmt = conn
|
||||
.prepare(
|
||||
"SELECT pt.id, pt.translation_for FROM post_translations pt \
|
||||
LEFT JOIN posts p ON pt.translation_for = p.id \
|
||||
WHERE p.id IS NULL",
|
||||
)
|
||||
.unwrap();
|
||||
let orphans: Vec<(String, String)> = stmt
|
||||
.query_map([], |row| Ok((row.get(0)?, row.get(1)?)))
|
||||
.unwrap()
|
||||
.map(|r| r.unwrap())
|
||||
.collect();
|
||||
|
||||
assert!(orphans.is_empty(), "orphan translations referencing missing posts: {orphans:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn published_translations_have_null_content() {
|
||||
let conn = fixture_db();
|
||||
let mut stmt = conn
|
||||
.prepare("SELECT id, content FROM post_translations WHERE status = 'published'")
|
||||
.unwrap();
|
||||
let rows: Vec<(String, Option<String>)> = stmt
|
||||
.query_map([], |row| Ok((row.get(0)?, row.get(1)?)))
|
||||
.unwrap()
|
||||
.map(|r| r.unwrap())
|
||||
.collect();
|
||||
|
||||
for (id, content) in &rows {
|
||||
assert!(content.is_none(), "published translation {id} must have NULL content");
|
||||
}
|
||||
}
|
||||
|
||||
// ── Post Links ──────────────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn read_post_links() {
|
||||
let conn = fixture_db();
|
||||
let (source, target, text): (String, String, Option<String>) = conn
|
||||
.query_row(
|
||||
"SELECT source_post_id, target_post_id, link_text FROM post_links LIMIT 1",
|
||||
[],
|
||||
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// ghostty links to cmux
|
||||
assert_eq!(source, "6745981d-da41-4cfd-80ec-95ad339acf6f");
|
||||
assert_eq!(target, "2665bfaa-8251-468d-a710-a4cf34dd81e2");
|
||||
assert!(text.is_some());
|
||||
}
|
||||
|
||||
// ── Post Media ──────────────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn read_post_media() {
|
||||
let conn = fixture_db();
|
||||
let (post_id, media_id, sort_order): (String, String, i32) = conn
|
||||
.query_row(
|
||||
"SELECT post_id, media_id, sort_order FROM post_media LIMIT 1",
|
||||
[],
|
||||
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// esmeralda <-> spider photo
|
||||
assert_eq!(post_id, "40a83ab1-423d-4310-aac4-642d84675007");
|
||||
assert_eq!(media_id, "eb0cf9d7-6fbd-4b74-9be3-759d6e16f240");
|
||||
assert_eq!(sort_order, 0);
|
||||
}
|
||||
|
||||
// ── Media ───────────────────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn read_media() {
|
||||
let conn = fixture_db();
|
||||
let (id, filename, original_name, mime_type, title, alt): (
|
||||
String,
|
||||
String,
|
||||
String,
|
||||
String,
|
||||
Option<String>,
|
||||
Option<String>,
|
||||
) = conn
|
||||
.query_row(
|
||||
"SELECT id, filename, original_name, mime_type, title, alt FROM media LIMIT 1",
|
||||
[],
|
||||
|row| {
|
||||
Ok((
|
||||
row.get(0)?,
|
||||
row.get(1)?,
|
||||
row.get(2)?,
|
||||
row.get(3)?,
|
||||
row.get(4)?,
|
||||
row.get(5)?,
|
||||
))
|
||||
},
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(id, "eb0cf9d7-6fbd-4b74-9be3-759d6e16f240");
|
||||
assert!(filename.ends_with(".jpg"));
|
||||
assert_eq!(original_name, "CRW_1121.jpg");
|
||||
assert_eq!(mime_type, "image/jpeg");
|
||||
assert!(title.is_some());
|
||||
assert!(alt.is_some());
|
||||
}
|
||||
|
||||
// ── Tags ────────────────────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn read_tags() {
|
||||
let conn = fixture_db();
|
||||
let count: i64 = conn
|
||||
.query_row("SELECT COUNT(*) FROM tags", [], |row| row.get(0))
|
||||
.unwrap();
|
||||
assert_eq!(count, 5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tag_names_are_expected() {
|
||||
let conn = fixture_db();
|
||||
let mut stmt = conn.prepare("SELECT name FROM tags ORDER BY name").unwrap();
|
||||
let names: Vec<String> = stmt
|
||||
.query_map([], |row| row.get(0))
|
||||
.unwrap()
|
||||
.map(|r| r.unwrap())
|
||||
.collect();
|
||||
|
||||
assert_eq!(names, vec!["fotografie", "mac-os-x", "natur", "programmierung", "sysadmin"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tag_unique_constraint_on_project_name() {
|
||||
let conn = fixture_db();
|
||||
let mut stmt = conn
|
||||
.prepare("SELECT project_id, name, COUNT(*) FROM tags GROUP BY project_id, name HAVING COUNT(*) > 1")
|
||||
.unwrap();
|
||||
let dupes: Vec<(String, String, i64)> = stmt
|
||||
.query_map([], |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)))
|
||||
.unwrap()
|
||||
.map(|r| r.unwrap())
|
||||
.collect();
|
||||
|
||||
assert!(dupes.is_empty(), "found duplicate (project_id, name) tag pairs: {dupes:?}");
|
||||
}
|
||||
|
||||
// ── Templates ───────────────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn read_template() {
|
||||
let conn = fixture_db();
|
||||
let (slug, title, kind, enabled, status, content): (
|
||||
String,
|
||||
String,
|
||||
String,
|
||||
bool,
|
||||
String,
|
||||
Option<String>,
|
||||
) = conn
|
||||
.query_row(
|
||||
"SELECT slug, title, kind, enabled, status, content FROM templates LIMIT 1",
|
||||
[],
|
||||
|row| {
|
||||
Ok((
|
||||
row.get(0)?,
|
||||
row.get(1)?,
|
||||
row.get(2)?,
|
||||
row.get(3)?,
|
||||
row.get(4)?,
|
||||
row.get(5)?,
|
||||
))
|
||||
},
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(slug, "testvorlage");
|
||||
assert_eq!(title, "Testvorlage");
|
||||
assert_eq!(kind, "post");
|
||||
assert!(enabled);
|
||||
assert_eq!(status, "published");
|
||||
assert!(content.is_none(), "published template content should be NULL in DB");
|
||||
}
|
||||
|
||||
// ── Scripts ─────────────────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn read_scripts() {
|
||||
let conn = fixture_db();
|
||||
let count: i64 = conn
|
||||
.query_row("SELECT COUNT(*) FROM scripts", [], |row| row.get(0))
|
||||
.unwrap();
|
||||
assert_eq!(count, 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_script_fields() {
|
||||
let conn = fixture_db();
|
||||
let (slug, title, kind, entrypoint, enabled, status): (
|
||||
String,
|
||||
String,
|
||||
String,
|
||||
String,
|
||||
bool,
|
||||
String,
|
||||
) = conn
|
||||
.query_row(
|
||||
"SELECT slug, title, kind, entrypoint, enabled, status FROM scripts WHERE slug = 'bgg_link'",
|
||||
[],
|
||||
|row| {
|
||||
Ok((
|
||||
row.get(0)?,
|
||||
row.get(1)?,
|
||||
row.get(2)?,
|
||||
row.get(3)?,
|
||||
row.get(4)?,
|
||||
row.get(5)?,
|
||||
))
|
||||
},
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(slug, "bgg_link");
|
||||
assert_eq!(title, "bgg link");
|
||||
assert_eq!(kind, "transform");
|
||||
assert_eq!(entrypoint, "normalize_blogmark");
|
||||
assert!(enabled);
|
||||
assert_eq!(status, "published");
|
||||
}
|
||||
|
||||
// ── Settings ────────────────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn read_settings() {
|
||||
let conn = fixture_db();
|
||||
let count: i64 = conn
|
||||
.query_row("SELECT COUNT(*) FROM settings", [], |row| row.get(0))
|
||||
.unwrap();
|
||||
assert_eq!(count, 5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn settings_are_key_value_pairs() {
|
||||
let conn = fixture_db();
|
||||
let mut stmt = conn.prepare("SELECT key, value FROM settings").unwrap();
|
||||
let pairs: Vec<(String, String)> = stmt
|
||||
.query_map([], |row| Ok((row.get(0)?, row.get(1)?)))
|
||||
.unwrap()
|
||||
.map(|r| r.unwrap())
|
||||
.collect();
|
||||
|
||||
for (key, value) in &pairs {
|
||||
assert!(!key.is_empty());
|
||||
assert!(!value.is_empty());
|
||||
}
|
||||
// All setting keys should contain the project ID (namespaced)
|
||||
let project_keys: Vec<_> = pairs.iter().filter(|(k, _)| k.contains(PROJECT_ID)).collect();
|
||||
assert_eq!(project_keys.len(), 5);
|
||||
}
|
||||
|
||||
// ── AI Catalog ──────────────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn read_ai_tables() {
|
||||
let conn = fixture_db();
|
||||
|
||||
let providers: i64 = conn
|
||||
.query_row("SELECT COUNT(*) FROM ai_providers", [], |row| row.get(0))
|
||||
.unwrap();
|
||||
let models: i64 = conn
|
||||
.query_row("SELECT COUNT(*) FROM ai_models", [], |row| row.get(0))
|
||||
.unwrap();
|
||||
let meta: i64 = conn
|
||||
.query_row("SELECT COUNT(*) FROM ai_catalog_meta", [], |row| row.get(0))
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(providers, 1);
|
||||
assert_eq!(models, 1);
|
||||
assert_eq!(meta, 2);
|
||||
}
|
||||
|
||||
// ── Generated File Hashes ───────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn read_generated_file_hashes_via_settings() {
|
||||
// The fixture stores generation hashes as settings keys
|
||||
let conn = fixture_db();
|
||||
let count: i64 = conn
|
||||
.query_row(
|
||||
"SELECT COUNT(*) FROM settings WHERE key LIKE '%generation-hash%'",
|
||||
[],
|
||||
|row| row.get(0),
|
||||
)
|
||||
.unwrap();
|
||||
assert!(count > 0, "expected generation hash entries in settings");
|
||||
}
|
||||
|
||||
// ── Cross-table referential integrity ───────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn all_posts_belong_to_existing_project() {
|
||||
let conn = fixture_db();
|
||||
let mut stmt = conn
|
||||
.prepare(
|
||||
"SELECT p.id FROM posts p \
|
||||
LEFT JOIN projects pr ON p.project_id = pr.id \
|
||||
WHERE pr.id IS NULL",
|
||||
)
|
||||
.unwrap();
|
||||
let orphans: Vec<String> = stmt
|
||||
.query_map([], |row| row.get(0))
|
||||
.unwrap()
|
||||
.map(|r| r.unwrap())
|
||||
.collect();
|
||||
|
||||
assert!(orphans.is_empty(), "posts referencing missing projects: {orphans:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn all_tags_belong_to_existing_project() {
|
||||
let conn = fixture_db();
|
||||
let mut stmt = conn
|
||||
.prepare(
|
||||
"SELECT t.id FROM tags t \
|
||||
LEFT JOIN projects pr ON t.project_id = pr.id \
|
||||
WHERE pr.id IS NULL",
|
||||
)
|
||||
.unwrap();
|
||||
let orphans: Vec<String> = stmt
|
||||
.query_map([], |row| row.get(0))
|
||||
.unwrap()
|
||||
.map(|r| r.unwrap())
|
||||
.collect();
|
||||
|
||||
assert!(orphans.is_empty(), "tags referencing missing projects: {orphans:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn all_media_belong_to_existing_project() {
|
||||
let conn = fixture_db();
|
||||
let mut stmt = conn
|
||||
.prepare(
|
||||
"SELECT m.id FROM media m \
|
||||
LEFT JOIN projects pr ON m.project_id = pr.id \
|
||||
WHERE pr.id IS NULL",
|
||||
)
|
||||
.unwrap();
|
||||
let orphans: Vec<String> = stmt
|
||||
.query_map([], |row| row.get(0))
|
||||
.unwrap()
|
||||
.map(|r| r.unwrap())
|
||||
.collect();
|
||||
|
||||
assert!(orphans.is_empty(), "media referencing missing projects: {orphans:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn post_links_reference_valid_posts() {
|
||||
let conn = fixture_db();
|
||||
let mut stmt = conn
|
||||
.prepare(
|
||||
"SELECT pl.id, pl.source_post_id, pl.target_post_id FROM post_links pl \
|
||||
LEFT JOIN posts s ON pl.source_post_id = s.id \
|
||||
LEFT JOIN posts t ON pl.target_post_id = t.id \
|
||||
WHERE s.id IS NULL OR t.id IS NULL",
|
||||
)
|
||||
.unwrap();
|
||||
let orphans: Vec<(String, String, String)> = stmt
|
||||
.query_map([], |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)))
|
||||
.unwrap()
|
||||
.map(|r| r.unwrap())
|
||||
.collect();
|
||||
|
||||
assert!(orphans.is_empty(), "post_links with invalid references: {orphans:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn post_media_references_valid_entities() {
|
||||
let conn = fixture_db();
|
||||
let mut stmt = conn
|
||||
.prepare(
|
||||
"SELECT pm.id FROM post_media pm \
|
||||
LEFT JOIN posts p ON pm.post_id = p.id \
|
||||
LEFT JOIN media m ON pm.media_id = m.id \
|
||||
WHERE p.id IS NULL OR m.id IS NULL",
|
||||
)
|
||||
.unwrap();
|
||||
let orphans: Vec<String> = stmt
|
||||
.query_map([], |row| row.get(0))
|
||||
.unwrap()
|
||||
.map(|r| r.unwrap())
|
||||
.collect();
|
||||
|
||||
assert!(orphans.is_empty(), "post_media with invalid references: {orphans:?}");
|
||||
}
|
||||
Reference in New Issue
Block a user