use std::collections::BTreeSet;
use std::sync::{Arc, Barrier};
use happenstance_core::StoreId;
use rusqlite::Connection;
use super::super::{WRITE_GROUP_SCHEMA_VERSION, migrate_to_2};
use crate::event_store::{SCHEMA_VERSION_KEY, apply_baseline, mint_identity};
use crate::test_support::TempFile;
fn migrate_to_version_2(connection: &mut Connection) -> StoreId {
let transaction = connection
.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)
.expect("the migration takes the write lock");
apply_baseline(&transaction).expect("migration 1 applies");
migrate_to_2(&transaction).expect("migration 2 applies");
mint_identity(&transaction).expect("the incarnation is minted");
let raw: Vec<u8> = transaction
.query_row(
"SELECT CAST(v AS BLOB) FROM store_meta WHERE k = 'store_id'",
[],
|row| row.get(0),
)
.expect("the incarnation reads back");
transaction.commit().expect("the migration commits");
StoreId::from_bytes(raw.try_into().expect("an incarnation is sixteen bytes"))
}
fn marker(connection: &Connection) -> i64 {
connection
.query_row(
"SELECT CAST(v AS INTEGER) FROM store_meta WHERE k = ?",
[SCHEMA_VERSION_KEY],
|row| row.get(0),
)
.expect("the marker reads")
}
fn schema_objects(connection: &Connection) -> BTreeSet<(String, String)> {
let mut statement = connection
.prepare("SELECT type, name FROM sqlite_master ORDER BY type, name")
.expect("sqlite_master reads");
let rows = statement
.query_map([], |row| {
Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
})
.expect("sqlite_master reads");
rows.collect::<Result<BTreeSet<_>, _>>()
.expect("every row reads")
.into_iter()
.filter(|(_, name)| !name.starts_with("sqlite_"))
.collect()
}
fn column_names(connection: &Connection, table: &str) -> Vec<String> {
let mut statement = connection
.prepare("SELECT name FROM pragma_table_info(?) ORDER BY cid")
.expect("the table info reads");
let rows = statement
.query_map([table], |row| row.get(0))
.expect("the table info reads");
rows.collect::<Result<_, _>>().expect("every column reads")
}
fn version_1_file(connection: &Connection) {
connection
.execute_batch(
"CREATE TABLE event (
position INTEGER PRIMARY KEY AUTOINCREMENT,
event_type TEXT NOT NULL,
data BLOB NOT NULL,
metadata BLOB,
tags BLOB NOT NULL,
origin_store BLOB,
origin_position INTEGER,
recorded_at INTEGER NOT NULL,
UNIQUE (origin_store, origin_position)
);
CREATE INDEX event_type_idx ON event(event_type, position);
CREATE TABLE event_tag (
tag TEXT NOT NULL,
position INTEGER NOT NULL REFERENCES event(position),
event_type TEXT NOT NULL,
PRIMARY KEY (tag, position)
) WITHOUT ROWID;
CREATE TABLE tag_cardinality (
tag TEXT PRIMARY KEY,
events INTEGER NOT NULL
) WITHOUT ROWID;
CREATE TABLE store_meta (
k TEXT PRIMARY KEY,
v BLOB NOT NULL
) WITHOUT ROWID;
INSERT INTO store_meta (k, v) VALUES ('schema_version', 1);
INSERT INTO store_meta (k, v) VALUES ('store_id', X'0123456789ABCDEF0123456789ABCDEF');
INSERT INTO event (event_type, data, metadata, tags, origin_store, origin_position, recorded_at)
VALUES ('Legacy', X'7B7D', NULL, X'1F', X'0123456789ABCDEF0123456789ABCDEF', 1, 0);",
)
.expect("the version-1 file is written");
}
#[test]
fn version_2_creates_the_amended_schema() {
let file = TempFile::new("amended-schema");
let mut connection = file.inspect();
migrate_to_version_2(&mut connection);
let expected: BTreeSet<(String, String)> = [
("index", "event_type_idx"),
("table", "event"),
("table", "event_tag"),
("table", "store_meta"),
("table", "tag_cardinality"),
]
.into_iter()
.map(|(kind, name)| (kind.to_owned(), name.to_owned()))
.collect();
assert_eq!(
schema_objects(&connection),
expected,
"sqlite_master after migration 2"
);
assert_eq!(marker(&connection), 2);
}
#[test]
fn concurrent_version_2_migrations_agree_on_one_store_id() {
let file = TempFile::new("concurrent");
let contenders = 8;
let barrier = Arc::new(Barrier::new(contenders));
let ids: BTreeSet<StoreId> = std::thread::scope(|scope| {
let handles: Vec<_> = (0..contenders)
.map(|_| {
let barrier = Arc::clone(&barrier);
let file = &file;
scope.spawn(move || {
let mut connection = file.inspect();
barrier.wait();
migrate_to_version_2(&mut connection)
})
})
.collect();
handles
.into_iter()
.map(|handle| handle.join().expect("a contender finished"))
.collect()
});
assert_eq!(ids.len(), 1, "two incarnations for one file: {ids:?}");
let connection = file.inspect();
let identity_rows: i64 = connection
.query_row(
"SELECT count(*) FROM store_meta WHERE k = 'store_id'",
[],
|row| row.get(0),
)
.expect("the identity rows count");
assert_eq!(identity_rows, 1);
assert_eq!(schema_objects(&connection).len(), 5);
}
#[test]
fn migration_2_adds_write_groups_to_a_version_1_file() {
let file = TempFile::new("migration-2");
let mut connection = file.inspect();
version_1_file(&connection);
migrate_to_version_2(&mut connection);
let store_id = migrate_to_version_2(&mut connection);
assert_eq!(store_id.to_bytes()[0], 0x01, "the identity survives");
let names = column_names(&connection, "event");
assert!(
names.iter().any(|name| name == "write_group")
&& names.iter().any(|name| name == "group_guard"),
"migration 2 did not add the write-group columns; got {names:?}"
);
assert_eq!(marker(&connection), 2, "the marker was not raised to 2");
assert_eq!(WRITE_GROUP_SCHEMA_VERSION, 2);
let legacy: (i64, Option<i64>) = connection
.query_row(
"SELECT count(*), max(write_group) FROM event WHERE event_type = 'Legacy'",
[],
|row| Ok((row.get(0)?, row.get(1)?)),
)
.expect("the legacy row reads");
assert_eq!(
legacy,
(1, None),
"the legacy row must survive with no write group: nothing recorded which rows one call wrote"
);
}
#[test]
fn migrating_a_version_1_file_leaves_it_at_2() {
let file = TempFile::new("new-v1");
let mut connection = file.inspect();
version_1_file(&connection);
assert_eq!(marker(&connection), 1);
migrate_to_version_2(&mut connection);
assert_eq!(marker(&connection), 2);
}
#[test]
fn a_fresh_file_is_created_at_version_2_with_write_groups() {
let file = TempFile::new("fresh-v2");
let mut connection = file.inspect();
migrate_to_version_2(&mut connection);
assert_eq!(marker(&connection), 2);
let names = column_names(&connection, "event");
assert!(
names.iter().any(|name| name == "write_group"),
"got {names:?}"
);
}