use ic_db::{Batch, Database, Date, Entity, Error, IndexValue, Schema, entity, map, set};
use ic_storage::{
AllocationGrants, GenericAllocationPolicy, MemoryAuthority, MemoryRequest, MemoryRuntime,
SealedDeclarationSnapshot, StableKey, VectorMemory, adapter::StableBTreeMap,
};
use std::collections::{BTreeMap, BTreeSet};
#[entity(pk(field="id"), index(fields=["zone","value","id"]),
index(field="maybe",unique,present_only), fields(
field(name="id",value(item(prim="Nat64"))),
field(name="maybe",value(opt,item(prim="Date"))),
field(name="value",value(item(prim="Date"))),
field(name="zone",value(item(prim="Bool")))))]
struct DateRow {}
#[set(item(prim = "Date"), max_items = 3)]
struct Ids {}
#[map(key(prim = "Date"), value(opt, item(prim = "Date")), max_items = 3)]
struct Links {}
#[entity(
pk(field = "id"),
fields(
field(name = "id", value(item(prim = "Nat64"))),
field(name = "list", value(many, max_items = 3, item(prim = "Date"))),
field(name = "map", value(item(is = "Links"))),
field(name = "set", value(item(is = "Ids")))
)
)]
struct Collections {}
fn host(backing: VectorMemory) -> MemoryRuntime<VectorMemory> {
let mut host = MemoryRuntime::new(backing).unwrap();
let req =
SealedDeclarationSnapshot::new(vec![MemoryRequest::new("test", "test.db.v1").unwrap()])
.unwrap();
let grants =
AllocationGrants::new(vec![MemoryAuthority::new("test", "test.").unwrap()]).unwrap();
host.bootstrap(&req, &grants, &GenericAllocationPolicy)
.unwrap();
host
}
fn values() -> [Date; 6] {
[-719528, -365, -1, 0, 1, 2932896].map(|d| Date::try_from_days_since_epoch(d).unwrap())
}
#[test]
fn calendar_and_epoch_days_agree_with_an_independent_day_counter() {
let mut epoch_day = -719_528;
for year in 0..=9999 {
let leap = year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
for (m, count) in [
31,
if leap { 29 } else { 28 },
31,
30,
31,
30,
31,
31,
30,
31,
30,
31,
]
.into_iter()
.enumerate()
{
for day in 1..=count {
let date = Date::try_from_days_since_epoch(epoch_day).unwrap();
assert_eq!(
(date.year(), date.month(), date.day()),
(year, m as u8 + 1, day)
);
assert_eq!(Date::try_new(year, m as u8 + 1, day), Some(date));
if year == 1970 && m == 0 && day == 1 {
assert_eq!(date, Date::EPOCH);
}
epoch_day += 1;
}
assert!(Date::try_new(year, m as u8 + 1, count + 1).is_none());
}
}
assert_eq!(epoch_day - 1, Date::MAX.as_days_since_epoch());
for text in [
"0000-01-01",
"1900-02-28",
"2000-02-29",
"1970-01-01",
"9999-12-31",
] {
assert_eq!(Date::parse(text).unwrap().to_string(), text);
}
for text in [
"1900-02-29",
"2100-02-29",
"2024-04-31",
"2024-1-01",
"2024-01-01T00:00:00Z",
"+024-01-01",
"2024-01-01",
] {
assert!(Date::parse(text).is_none());
}
for year in [-1, 10000, i32::MAX] {
assert!(Date::try_new(year, 1, 1).is_none());
}
assert_eq!(
Date::try_new(2000, 2, 28).unwrap().checked_add_days(1),
Date::try_new(2000, 2, 29)
);
assert!(Date::MAX.checked_add_days(1).is_none());
assert!(Date::MIN.checked_sub_days(1).is_none());
assert!(Date::EPOCH.checked_add_days(i64::MAX).is_none());
assert!(Date::EPOCH.checked_sub_days(i64::MIN).is_none());
}
#[test]
fn exact_date_bytes_and_invalid_stored_domains() {
assert_eq!(
Schema::new(&[DateRow::SCHEMA])
.unwrap()
.fingerprint()
.map(|b| format!("{b:02x}"))
.concat(),
"9f5e19d2556292998de7aea40084f804bc1bb2ab400b3d18e7372d131f29dc4e"
);
for value in values() {
let row = DateRow {
id: 7,
maybe: Some(value),
value,
zone: true,
};
assert_eq!(DateRow::decode(&row.encode().unwrap()).unwrap(), row);
}
let row = DateRow {
id: 7,
maybe: None,
value: Date::try_new(1969, 12, 31).unwrap(),
zone: true,
};
let golden = vec![7, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 1];
assert_eq!(row.encode().unwrap(), golden);
for end in 0..golden.len() {
assert!(matches!(
DateRow::decode(&golden[..end]),
Err(Error::Corrupt)
));
}
let mut excess = golden.clone();
excess.push(0);
assert!(matches!(DateRow::decode(&excess), Err(Error::Corrupt)));
for invalid in [i32::MIN, -719529, 2932897, i32::MAX] {
let mut bad = golden.clone();
bad[9..13].copy_from_slice(&invalid.to_le_bytes());
assert!(matches!(DateRow::decode(&bad), Err(Error::Corrupt)));
}
}
#[test]
fn ordered_indexes_swaps_noops_refusals_and_reopen() {
let backing = VectorMemory::default();
let runtime = host(backing.clone());
let slot = StableKey::parse("test.db.v1").unwrap();
let schema = || Schema::new(&[DateRow::SCHEMA]).unwrap();
let mut db = Database::create(runtime.open_memory(&slot).unwrap(), schema(), [9; 16]).unwrap();
let mut rows: Vec<_> = values()
.into_iter()
.enumerate()
.map(|(i, value)| DateRow {
id: i as u64 + 1,
maybe: Some(value),
value,
zone: true,
})
.collect();
let mut batch = Batch::new();
for r in rows.iter().rev() {
batch.insert(r).unwrap();
}
db.commit(batch).unwrap();
let read = |db: &Database<VectorMemory>| {
db.index_prefix::<DateRow>("zone,value,id", &[true.into()], 32)
.unwrap()
.into_iter()
.map(|r| r.id)
.collect::<Vec<_>>()
};
assert_eq!(read(&db), vec![1, 2, 3, 4, 5, 6]);
for pair in values().windows(2) {
assert!(pair[0] < pair[1]);
let key = |v: Date| ic_db::__private::encode_index(&[(v.into(), false)], false).unwrap();
assert_eq!(
key(pair[0]),
((pair[0].as_days_since_epoch() as u32) ^ 0x80000000).to_be_bytes()
);
assert!(key(pair[0]) < key(pair[1]));
}
assert!(matches!(
db.index_prefix::<DateRow>("maybe", &[IndexValue::Nat128(0)], 32),
Err(Error::InvalidOperand)
));
let before = backing.borrow().clone();
let mut b = Batch::new();
b.replace(&rows[0]).unwrap();
db.commit(b).unwrap();
assert_eq!(*backing.borrow(), before);
let duplicate = DateRow {
maybe: Some(Date::MAX),
..rows[0].clone()
};
let mut b = Batch::new();
b.replace(&duplicate).unwrap();
assert!(matches!(db.commit(b), Err(Error::UniqueViolation)));
assert_eq!(*backing.borrow(), before);
rows[0].maybe = Some(Date::MAX);
rows[5].maybe = Some(Date::MIN);
let mut b = Batch::new();
b.replace(&rows[0]).unwrap();
b.replace(&rows[5]).unwrap();
db.commit(b).unwrap();
assert_eq!(
db.index_prefix::<DateRow>("maybe", &[Date::MAX.into()], 32)
.unwrap()[0]
.id,
1
);
drop(db);
let db = Database::open(runtime.open_memory(&slot).unwrap(), schema()).unwrap();
assert_eq!(read(&db), vec![1, 2, 3, 4, 5, 6]);
for r in rows {
assert_eq!(db.get::<DateRow>(r.id).unwrap(), Some(r));
}
drop(db);
let mut raw = StableBTreeMap::<Vec<u8>, Vec<u8>, _>::load(runtime.open_memory(&slot).unwrap());
let index = DateRow::SCHEMA
.indexes
.iter()
.find(|i| i.name == "zone,value,id")
.unwrap();
let mut physical = vec![3];
physical.extend(DateRow::ID.to_be_bytes());
physical.extend(index.id.to_be_bytes());
physical.push(1);
physical.extend([128, 44, 192, 160]);
physical.extend(6_u64.to_be_bytes());
physical.extend(6_u64.to_be_bytes());
assert!(raw.get(&physical).is_some());
let mut short = physical.clone();
short[10..14].copy_from_slice(&[255; 4]);
raw.remove(&physical);
raw.insert(short, 6_u64.to_be_bytes().to_vec());
drop(raw);
let db = Database::open(runtime.open_memory(&slot).unwrap(), schema()).unwrap();
assert!(matches!(
db.index_prefix::<DateRow>("zone,value,id", &[true.into()], 32),
Err(Error::Corrupt)
));
}
#[test]
fn collections_reject_duplicate_keys_before_materialization() {
let row = Collections {
id: 1,
list: vec![Date::MAX, Date::MIN, Date::MAX],
map: Links(BTreeMap::from([
(Date::MIN, None),
(Date::MAX, Some(Date::MIN)),
])),
set: Ids(BTreeSet::from([Date::MIN, Date::MAX])),
};
let bytes = row.encode().unwrap();
assert_eq!(Collections::decode(&bytes).unwrap(), row);
assert_eq!(&bytes[12..16], &2932896_i32.to_le_bytes());
assert_eq!(&bytes[16..20], &(-719528_i32).to_le_bytes());
let mut duplicate = bytes;
let first = duplicate[28..32].to_vec();
duplicate[33..37].copy_from_slice(&first);
assert!(matches!(
Collections::decode(&duplicate),
Err(Error::Corrupt)
));
let backing = VectorMemory::default();
let runtime = host(backing.clone());
let slot = StableKey::parse("test.db.v1").unwrap();
let schema = || Schema::new(&[Collections::SCHEMA]).unwrap();
let mut db = Database::create(runtime.open_memory(&slot).unwrap(), schema(), [9; 16]).unwrap();
let mut b = Batch::new();
b.insert(&row).unwrap();
db.commit(b).unwrap();
drop(db);
let mut raw = StableBTreeMap::<Vec<u8>, Vec<u8>, _>::load(runtime.open_memory(&slot).unwrap());
let mut key = vec![2];
key.extend(Collections::ID.to_be_bytes());
key.extend(1_u64.to_be_bytes());
let mut invalid_date = row.encode().unwrap();
invalid_date[12..16].copy_from_slice(&i32::MAX.to_le_bytes());
raw.insert(key, invalid_date);
drop(raw);
let mut db = Database::open(runtime.open_memory(&slot).unwrap(), schema()).unwrap();
let before = backing.borrow().clone();
let mut b = Batch::new();
b.delete::<Collections>(1).unwrap();
assert!(matches!(db.commit(b), Err(Error::Corrupt)));
assert_eq!(*backing.borrow(), before);
}
#[entity(
pk(field = "id"),
fields(
field(name = "id", value(item(prim = "Nat64"))),
field(name = "values", value(many, max_items = 256, item(prim = "Date")))
)
)]
struct WideList {}
#[test]
fn lists_obey_the_shared_item_bound() {
let row = WideList {
id: 1,
values: vec![Date::MAX; 256],
};
let bytes = row.encode().unwrap();
assert_eq!(bytes.len(), 1036);
assert_eq!(WideList::decode(&bytes).unwrap(), row);
let mut oversized = row;
oversized.values.push(Date::MAX);
assert!(matches!(oversized.encode(), Err(Error::Limit)));
}