use std::collections::BTreeMap;
use crate::emp::PullEvseDataRecord;
use crate::types::{DateTime, EvseId};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct ApplyOutcome {
pub inserted: u64,
pub updated: u64,
pub updated_unknown: u64,
pub deleted: u64,
pub deleted_unknown: u64,
}
impl ApplyOutcome {
#[must_use]
pub const fn total(&self) -> u64 {
self.inserted + self.updated + self.updated_unknown + self.deleted + self.deleted_unknown
}
#[must_use]
pub const fn suggests_drift(&self) -> bool {
self.updated_unknown > 0 || self.deleted_unknown > 0
}
pub fn merge(&mut self, other: Self) {
self.inserted += other.inserted;
self.updated += other.updated;
self.updated_unknown += other.updated_unknown;
self.deleted += other.deleted;
self.deleted_unknown += other.deleted_unknown;
}
}
pub trait EvseRepository {
type Error;
fn upsert(&mut self, record: PullEvseDataRecord) -> Result<bool, Self::Error>;
fn delete(&mut self, evse_id: &EvseId) -> Result<bool, Self::Error>;
fn get(&self, evse_id: &EvseId) -> Result<Option<PullEvseDataRecord>, Self::Error>;
fn len(&self) -> Result<u64, Self::Error>;
fn is_empty(&self) -> Result<bool, Self::Error> {
Ok(self.len()? == 0)
}
fn last_call(&self) -> Result<Option<DateTime>, Self::Error>;
fn set_last_call(&mut self, at: DateTime) -> Result<(), Self::Error>;
fn clear(&mut self) -> Result<(), Self::Error>;
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)]
#[error("the in-memory repository cannot fail")]
pub enum RepositoryError {}
#[derive(Clone, Debug, Default)]
pub struct InMemoryEvseRepository {
records: BTreeMap<EvseId, PullEvseDataRecord>,
last_call: Option<DateTime>,
}
impl InMemoryEvseRepository {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn iter(&self) -> impl Iterator<Item = &PullEvseDataRecord> {
self.records.values()
}
#[must_use]
pub fn into_records(self) -> Vec<PullEvseDataRecord> {
self.records.into_values().collect()
}
#[must_use]
pub fn keys(&self) -> Vec<&EvseId> {
self.records.keys().collect()
}
}
impl EvseRepository for InMemoryEvseRepository {
type Error = RepositoryError;
fn upsert(&mut self, record: PullEvseDataRecord) -> Result<bool, Self::Error> {
Ok(self.records.insert(record.evse_id.clone(), record).is_none())
}
fn delete(&mut self, evse_id: &EvseId) -> Result<bool, Self::Error> {
Ok(self.records.remove(evse_id).is_some())
}
fn get(&self, evse_id: &EvseId) -> Result<Option<PullEvseDataRecord>, Self::Error> {
Ok(self.records.get(evse_id).cloned())
}
fn len(&self) -> Result<u64, Self::Error> {
Ok(self.records.len() as u64)
}
fn last_call(&self) -> Result<Option<DateTime>, Self::Error> {
Ok(self.last_call.clone())
}
fn set_last_call(&mut self, at: DateTime) -> Result<(), Self::Error> {
self.last_call = Some(at);
Ok(())
}
fn clear(&mut self) -> Result<(), Self::Error> {
self.records.clear();
Ok(())
}
}
#[cfg(all(test, feature = "testkit"))]
mod tests {
use super::*;
use crate::testkit::samples;
#[test]
fn the_same_charging_spot_written_two_ways_is_one_record() {
let mut repo = InMemoryEvseRepository::new();
let spaced = samples::pull_evse_data_record("DE*ABC*E1");
let packed = samples::pull_evse_data_record("DEABCE1");
assert!(repo.upsert(spaced).unwrap(), "the first is new");
assert!(!repo.upsert(packed).unwrap(), "the second is the same charging spot");
assert_eq!(repo.len().unwrap(), 1);
}
#[test]
fn reading_the_whole_copy_back_yields_the_whole_copy() {
let mut repository = InMemoryEvseRepository::new();
repository.upsert(samples::pull_evse_data_record("DE*ABC*E2")).unwrap();
repository.upsert(samples::pull_evse_data_record("DE*ABC*E1")).unwrap();
let keys: Vec<String> = repository.keys().into_iter().map(EvseId::canonical).collect();
assert_eq!(keys, vec!["DEABCE1".to_owned(), "DEABCE2".to_owned()], "in EvseID order");
let iterated: Vec<String> = repository.iter().map(|r| r.evse_id.canonical()).collect();
assert_eq!(iterated, keys);
let records = repository.into_records();
assert_eq!(records.len(), 2);
assert_eq!(records.iter().map(|r| r.evse_id.canonical()).collect::<Vec<_>>(), keys);
}
#[test]
fn an_outcome_counts_drift_separately_from_normal_work() {
let mut outcome = ApplyOutcome { inserted: 10, updated: 5, ..ApplyOutcome::default() };
assert!(!outcome.suggests_drift());
assert_eq!(outcome.total(), 15);
outcome.merge(ApplyOutcome { deleted_unknown: 1, ..ApplyOutcome::default() });
assert!(outcome.suggests_drift());
assert_eq!(outcome.total(), 16);
}
#[test]
fn the_arithmetic_holds_with_every_counter_in_play() {
let one =
ApplyOutcome { inserted: 1, updated: 2, updated_unknown: 4, deleted: 8, deleted_unknown: 16 };
assert_eq!(one.total(), 31);
let two = ApplyOutcome {
inserted: 32,
updated: 64,
updated_unknown: 128,
deleted: 256,
deleted_unknown: 512,
};
let mut merged = one;
merged.merge(two);
assert_eq!(merged.inserted, 33);
assert_eq!(merged.updated, 66);
assert_eq!(merged.updated_unknown, 132);
assert_eq!(merged.deleted, 264);
assert_eq!(merged.deleted_unknown, 528);
assert_eq!(merged.total(), 1023);
}
#[test]
fn either_kind_of_drift_is_drift_on_its_own() {
let updated = ApplyOutcome { updated_unknown: 1, ..ApplyOutcome::default() };
assert!(updated.suggests_drift(), "an update for a record we never had is drift");
let deleted = ApplyOutcome { deleted_unknown: 1, ..ApplyOutcome::default() };
assert!(deleted.suggests_drift(), "a delete for a record we never had is drift");
let ordinary = ApplyOutcome { inserted: 99, updated: 99, deleted: 99, ..ApplyOutcome::default() };
assert!(!ordinary.suggests_drift(), "ordinary work is not drift");
assert!(!ApplyOutcome::default().suggests_drift());
}
}