move contents of taskchampion repo to tc/

rust/taskchampion/src/storage/config.rs

@@ -0,0 +1,22 @@
+use super::{InMemoryStorage, SqliteStorage, Storage};
+use std::path::PathBuf;
+
+/// The configuration required for a replica's storage.
+pub enum StorageConfig {
+    /// Store the data on disk.  This is the common choice.
+    OnDisk {
+        /// Path containing the task DB.
+        taskdb_dir: PathBuf,
+    },
+    /// Store the data in memory.  This is only useful for testing.
+    InMemory,
+}
+
+impl StorageConfig {
+    pub fn into_storage(self) -> anyhow::Result<Box<dyn Storage>> {
+        Ok(match self {
+            StorageConfig::OnDisk { taskdb_dir } => Box::new(SqliteStorage::new(taskdb_dir)?),
+            StorageConfig::InMemory => Box::new(InMemoryStorage::new()),
+        })
+    }
+}

rust/taskchampion/src/storage/inmemory.rs

@@ -0,0 +1,242 @@
+#![allow(clippy::new_without_default)]
+
+use crate::storage::{ReplicaOp, Storage, StorageTxn, TaskMap, VersionId, DEFAULT_BASE_VERSION};
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+use uuid::Uuid;
+
+#[derive(PartialEq, Debug, Clone)]
+struct Data {
+    tasks: HashMap<Uuid, TaskMap>,
+    base_version: VersionId,
+    operations: Vec<ReplicaOp>,
+    working_set: Vec<Option<Uuid>>,
+}
+
+struct Txn<'t> {
+    storage: &'t mut InMemoryStorage,
+    new_data: Option<Data>,
+}
+
+impl<'t> Txn<'t> {
+    fn mut_data_ref(&mut self) -> &mut Data {
+        if self.new_data.is_none() {
+            self.new_data = Some(self.storage.data.clone());
+        }
+        if let Some(ref mut data) = self.new_data {
+            data
+        } else {
+            unreachable!();
+        }
+    }
+
+    fn data_ref(&mut self) -> &Data {
+        if let Some(ref data) = self.new_data {
+            data
+        } else {
+            &self.storage.data
+        }
+    }
+}
+
+impl<'t> StorageTxn for Txn<'t> {
+    fn get_task(&mut self, uuid: Uuid) -> anyhow::Result<Option<TaskMap>> {
+        match self.data_ref().tasks.get(&uuid) {
+            None => Ok(None),
+            Some(t) => Ok(Some(t.clone())),
+        }
+    }
+
+    fn create_task(&mut self, uuid: Uuid) -> anyhow::Result<bool> {
+        if let ent @ Entry::Vacant(_) = self.mut_data_ref().tasks.entry(uuid) {
+            ent.or_insert_with(TaskMap::new);
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    fn set_task(&mut self, uuid: Uuid, task: TaskMap) -> anyhow::Result<()> {
+        self.mut_data_ref().tasks.insert(uuid, task);
+        Ok(())
+    }
+
+    fn delete_task(&mut self, uuid: Uuid) -> anyhow::Result<bool> {
+        Ok(self.mut_data_ref().tasks.remove(&uuid).is_some())
+    }
+
+    fn all_tasks<'a>(&mut self) -> anyhow::Result<Vec<(Uuid, TaskMap)>> {
+        Ok(self
+            .data_ref()
+            .tasks
+            .iter()
+            .map(|(u, t)| (*u, t.clone()))
+            .collect())
+    }
+
+    fn all_task_uuids<'a>(&mut self) -> anyhow::Result<Vec<Uuid>> {
+        Ok(self.data_ref().tasks.keys().copied().collect())
+    }
+
+    fn base_version(&mut self) -> anyhow::Result<VersionId> {
+        Ok(self.data_ref().base_version)
+    }
+
+    fn set_base_version(&mut self, version: VersionId) -> anyhow::Result<()> {
+        self.mut_data_ref().base_version = version;
+        Ok(())
+    }
+
+    fn operations(&mut self) -> anyhow::Result<Vec<ReplicaOp>> {
+        Ok(self.data_ref().operations.clone())
+    }
+
+    fn num_operations(&mut self) -> anyhow::Result<usize> {
+        Ok(self.data_ref().operations.len())
+    }
+
+    fn add_operation(&mut self, op: ReplicaOp) -> anyhow::Result<()> {
+        self.mut_data_ref().operations.push(op);
+        Ok(())
+    }
+
+    fn set_operations(&mut self, ops: Vec<ReplicaOp>) -> anyhow::Result<()> {
+        self.mut_data_ref().operations = ops;
+        Ok(())
+    }
+
+    fn get_working_set(&mut self) -> anyhow::Result<Vec<Option<Uuid>>> {
+        Ok(self.data_ref().working_set.clone())
+    }
+
+    fn add_to_working_set(&mut self, uuid: Uuid) -> anyhow::Result<usize> {
+        let working_set = &mut self.mut_data_ref().working_set;
+        working_set.push(Some(uuid));
+        Ok(working_set.len())
+    }
+
+    fn set_working_set_item(&mut self, index: usize, uuid: Option<Uuid>) -> anyhow::Result<()> {
+        let working_set = &mut self.mut_data_ref().working_set;
+        if index >= working_set.len() {
+            anyhow::bail!("Index {} is not in the working set", index);
+        }
+        working_set[index] = uuid;
+        Ok(())
+    }
+
+    fn clear_working_set(&mut self) -> anyhow::Result<()> {
+        self.mut_data_ref().working_set = vec![None];
+        Ok(())
+    }
+
+    fn commit(&mut self) -> anyhow::Result<()> {
+        // copy the new_data back into storage to commit the transaction
+        if let Some(data) = self.new_data.take() {
+            self.storage.data = data;
+        }
+        Ok(())
+    }
+}
+
+/// InMemoryStorage is a simple in-memory task storage implementation.  It is not useful for
+/// production data, but is useful for testing purposes.
+#[derive(PartialEq, Debug, Clone)]
+pub struct InMemoryStorage {
+    data: Data,
+}
+
+impl InMemoryStorage {
+    pub fn new() -> InMemoryStorage {
+        InMemoryStorage {
+            data: Data {
+                tasks: HashMap::new(),
+                base_version: DEFAULT_BASE_VERSION,
+                operations: vec![],
+                working_set: vec![None],
+            },
+        }
+    }
+}
+
+impl Storage for InMemoryStorage {
+    fn txn<'a>(&'a mut self) -> anyhow::Result<Box<dyn StorageTxn + 'a>> {
+        Ok(Box::new(Txn {
+            storage: self,
+            new_data: None,
+        }))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    // (note: this module is heavily used in tests so most of its functionality is well-tested
+    // elsewhere and not tested here)
+
+    #[test]
+    fn get_working_set_empty() -> anyhow::Result<()> {
+        let mut storage = InMemoryStorage::new();
+
+        {
+            let mut txn = storage.txn()?;
+            let ws = txn.get_working_set()?;
+            assert_eq!(ws, vec![None]);
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn add_to_working_set() -> anyhow::Result<()> {
+        let mut storage = InMemoryStorage::new();
+        let uuid1 = Uuid::new_v4();
+        let uuid2 = Uuid::new_v4();
+
+        {
+            let mut txn = storage.txn()?;
+            txn.add_to_working_set(uuid1)?;
+            txn.add_to_working_set(uuid2)?;
+            txn.commit()?;
+        }
+
+        {
+            let mut txn = storage.txn()?;
+            let ws = txn.get_working_set()?;
+            assert_eq!(ws, vec![None, Some(uuid1), Some(uuid2)]);
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn clear_working_set() -> anyhow::Result<()> {
+        let mut storage = InMemoryStorage::new();
+        let uuid1 = Uuid::new_v4();
+        let uuid2 = Uuid::new_v4();
+
+        {
+            let mut txn = storage.txn()?;
+            txn.add_to_working_set(uuid1)?;
+            txn.add_to_working_set(uuid2)?;
+            txn.commit()?;
+        }
+
+        {
+            let mut txn = storage.txn()?;
+            txn.clear_working_set()?;
+            txn.add_to_working_set(uuid2)?;
+            txn.add_to_working_set(uuid1)?;
+            txn.commit()?;
+        }
+
+        {
+            let mut txn = storage.txn()?;
+            let ws = txn.get_working_set()?;
+            assert_eq!(ws, vec![None, Some(uuid2), Some(uuid1)]);
+        }
+
+        Ok(())
+    }
+}

rust/taskchampion/src/storage/mod.rs

@@ -0,0 +1,133 @@
+/**
+This module defines the backend storage used by [`Replica`](crate::Replica).
+It defines a [trait](crate::storage::Storage) for storage implementations, and provides a default on-disk implementation as well as an in-memory implementation for testing.
+
+Typical uses of this crate do not interact directly with this module; [`StorageConfig`](crate::StorageConfig) is sufficient.
+However, users who wish to implement their own storage backends can implement the traits defined here and pass the result to [`Replica`](crate::Replica).
+*/
+use anyhow::Result;
+use std::collections::HashMap;
+use uuid::Uuid;
+
+mod config;
+mod inmemory;
+mod op;
+pub(crate) mod sqlite;
+
+pub use config::StorageConfig;
+pub use inmemory::InMemoryStorage;
+pub use sqlite::SqliteStorage;
+
+pub use op::ReplicaOp;
+
+/// An in-memory representation of a task as a simple hashmap
+pub type TaskMap = HashMap<String, String>;
+
+#[cfg(test)]
+fn taskmap_with(mut properties: Vec<(String, String)>) -> TaskMap {
+    let mut rv = TaskMap::new();
+    for (p, v) in properties.drain(..) {
+        rv.insert(p, v);
+    }
+    rv
+}
+
+/// The type of VersionIds
+pub use crate::server::VersionId;
+
+/// The default for base_version.
+pub(crate) const DEFAULT_BASE_VERSION: Uuid = crate::server::NIL_VERSION_ID;
+
+/// A Storage transaction, in which storage operations are performed.
+///
+/// # Concurrency
+///
+/// Serializable consistency must be maintained.  Concurrent access is unusual
+/// and some implementations may simply apply a mutex to limit access to
+/// one transaction at a time.
+///
+/// # Commiting and Aborting
+///
+/// A transaction is not visible to other readers until it is committed with
+/// [`crate::storage::StorageTxn::commit`].  Transactions are aborted if they are dropped.
+/// It is safe and performant to drop transactions that did not modify any data without committing.
+pub trait StorageTxn {
+    /// Get an (immutable) task, if it is in the storage
+    fn get_task(&mut self, uuid: Uuid) -> Result<Option<TaskMap>>;
+
+    /// Create an (empty) task, only if it does not already exist.  Returns true if
+    /// the task was created (did not already exist).
+    fn create_task(&mut self, uuid: Uuid) -> Result<bool>;
+
+    /// Set a task, overwriting any existing task.  If the task does not exist, this implicitly
+    /// creates it (use `get_task` to check first, if necessary).
+    fn set_task(&mut self, uuid: Uuid, task: TaskMap) -> Result<()>;
+
+    /// Delete a task, if it exists.  Returns true if the task was deleted (already existed)
+    fn delete_task(&mut self, uuid: Uuid) -> Result<bool>;
+
+    /// Get the uuids and bodies of all tasks in the storage, in undefined order.
+    fn all_tasks(&mut self) -> Result<Vec<(Uuid, TaskMap)>>;
+
+    /// Get the uuids of all tasks in the storage, in undefined order.
+    fn all_task_uuids(&mut self) -> Result<Vec<Uuid>>;
+
+    /// Get the current base_version for this storage -- the last version synced from the server.
+    fn base_version(&mut self) -> Result<VersionId>;
+
+    /// Set the current base_version for this storage.
+    fn set_base_version(&mut self, version: VersionId) -> Result<()>;
+
+    /// Get the current set of outstanding operations (operations that have not been sync'd to the
+    /// server yet)
+    fn operations(&mut self) -> Result<Vec<ReplicaOp>>;
+
+    /// Get the current set of outstanding operations (operations that have not been sync'd to the
+    /// server yet)
+    fn num_operations(&mut self) -> Result<usize>;
+
+    /// Add an operation to the end of the list of operations in the storage.  Note that this
+    /// merely *stores* the operation; it is up to the TaskDb to apply it.
+    fn add_operation(&mut self, op: ReplicaOp) -> Result<()>;
+
+    /// Replace the current list of operations with a new list.
+    fn set_operations(&mut self, ops: Vec<ReplicaOp>) -> Result<()>;
+
+    /// Get the entire working set, with each task UUID at its appropriate (1-based) index.
+    /// Element 0 is always None.
+    fn get_working_set(&mut self) -> Result<Vec<Option<Uuid>>>;
+
+    /// Add a task to the working set and return its (one-based) index.  This index will be one greater
+    /// than the highest used index.
+    fn add_to_working_set(&mut self, uuid: Uuid) -> Result<usize>;
+
+    /// Update the working set task at the given index.  This cannot add a new item to the
+    /// working set.
+    fn set_working_set_item(&mut self, index: usize, uuid: Option<Uuid>) -> Result<()>;
+
+    /// Clear all tasks from the working set in preparation for a garbage-collection operation.
+    /// Note that this is the only way items are removed from the set.
+    fn clear_working_set(&mut self) -> Result<()>;
+
+    /// Check whether this storage is entirely empty
+    #[allow(clippy::wrong_self_convention)] // mut is required here for storage access
+    fn is_empty(&mut self) -> Result<bool> {
+        let mut empty = true;
+        empty = empty && self.all_tasks()?.is_empty();
+        empty = empty && self.get_working_set()? == vec![None];
+        empty = empty && self.base_version()? == Uuid::nil();
+        empty = empty && self.operations()?.is_empty();
+        Ok(empty)
+    }
+
+    /// Commit any changes made in the transaction.  It is an error to call this more than
+    /// once.
+    fn commit(&mut self) -> Result<()>;
+}
+
+/// A trait for objects able to act as task storage.  Most of the interesting behavior is in the
+/// [`crate::storage::StorageTxn`] trait.
+pub trait Storage {
+    /// Begin a transaction
+    fn txn<'a>(&'a mut self) -> Result<Box<dyn StorageTxn + 'a>>;
+}

rust/taskchampion/src/storage/op.rs

@@ -0,0 +1,283 @@
+use crate::server::SyncOp;
+use crate::storage::TaskMap;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+/// A ReplicaOp defines a single change to the task database, as stored locally in the replica.
+/// This contains additional information not included in SyncOp.
+#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
+pub enum ReplicaOp {
+    /// Create a new task.
+    ///
+    /// On undo, the task is deleted.
+    Create { uuid: Uuid },
+
+    /// Delete an existing task.
+    ///
+    /// On undo, the task's data is restored from old_task.
+    Delete { uuid: Uuid, old_task: TaskMap },
+
+    /// Update an existing task, setting the given property to the given value.  If the value is
+    /// None, then the corresponding property is deleted.
+    ///
+    /// On undo, the property is set back to its previous value.
+    Update {
+        uuid: Uuid,
+        property: String,
+        old_value: Option<String>,
+        value: Option<String>,
+        timestamp: DateTime<Utc>,
+    },
+
+    /// Mark a point in the operations history to which the user might like to undo.  Users
+    /// typically want to undo more than one operation at a time (for example, most changes update
+    /// both the `modified` property and some other task property -- the user would like to "undo"
+    /// both updates at the same time).  Applying an UndoPoint does nothing.
+    UndoPoint,
+}
+
+impl ReplicaOp {
+    /// Convert this operation into a [`SyncOp`].
+    pub fn into_sync(self) -> Option<SyncOp> {
+        match self {
+            Self::Create { uuid } => Some(SyncOp::Create { uuid }),
+            Self::Delete { uuid, .. } => Some(SyncOp::Delete { uuid }),
+            Self::Update {
+                uuid,
+                property,
+                value,
+                timestamp,
+                ..
+            } => Some(SyncOp::Update {
+                uuid,
+                property,
+                value,
+                timestamp,
+            }),
+            Self::UndoPoint => None,
+        }
+    }
+
+    /// Generate a sequence of SyncOp's to reverse the effects of this ReplicaOp.
+    pub fn reverse_ops(self) -> Vec<SyncOp> {
+        match self {
+            Self::Create { uuid } => vec![SyncOp::Delete { uuid }],
+            Self::Delete { uuid, mut old_task } => {
+                let mut ops = vec![SyncOp::Create { uuid }];
+                // We don't have the original update timestamp, but it doesn't
+                // matter because this SyncOp will just be applied and discarded.
+                let timestamp = Utc::now();
+                for (property, value) in old_task.drain() {
+                    ops.push(SyncOp::Update {
+                        uuid,
+                        property,
+                        value: Some(value),
+                        timestamp,
+                    });
+                }
+                ops
+            }
+            Self::Update {
+                uuid,
+                property,
+                old_value,
+                timestamp,
+                ..
+            } => vec![SyncOp::Update {
+                uuid,
+                property,
+                value: old_value,
+                timestamp,
+            }],
+            Self::UndoPoint => vec![],
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::storage::taskmap_with;
+    use chrono::Utc;
+    use pretty_assertions::assert_eq;
+
+    use ReplicaOp::*;
+
+    #[test]
+    fn test_json_create() -> anyhow::Result<()> {
+        let uuid = Uuid::new_v4();
+        let op = Create { uuid };
+        let json = serde_json::to_string(&op)?;
+        assert_eq!(json, format!(r#"{{"Create":{{"uuid":"{}"}}}}"#, uuid));
+        let deser: ReplicaOp = serde_json::from_str(&json)?;
+        assert_eq!(deser, op);
+        Ok(())
+    }
+
+    #[test]
+    fn test_json_delete() -> anyhow::Result<()> {
+        let uuid = Uuid::new_v4();
+        let old_task = vec![("foo".into(), "bar".into())].drain(..).collect();
+        let op = Delete { uuid, old_task };
+        let json = serde_json::to_string(&op)?;
+        assert_eq!(
+            json,
+            format!(
+                r#"{{"Delete":{{"uuid":"{}","old_task":{{"foo":"bar"}}}}}}"#,
+                uuid
+            )
+        );
+        let deser: ReplicaOp = serde_json::from_str(&json)?;
+        assert_eq!(deser, op);
+        Ok(())
+    }
+
+    #[test]
+    fn test_json_update() -> anyhow::Result<()> {
+        let uuid = Uuid::new_v4();
+        let timestamp = Utc::now();
+
+        let op = Update {
+            uuid,
+            property: "abc".into(),
+            old_value: Some("true".into()),
+            value: Some("false".into()),
+            timestamp,
+        };
+
+        let json = serde_json::to_string(&op)?;
+        assert_eq!(
+            json,
+            format!(
+                r#"{{"Update":{{"uuid":"{}","property":"abc","old_value":"true","value":"false","timestamp":"{:?}"}}}}"#,
+                uuid, timestamp,
+            )
+        );
+        let deser: ReplicaOp = serde_json::from_str(&json)?;
+        assert_eq!(deser, op);
+        Ok(())
+    }
+
+    #[test]
+    fn test_json_update_none() -> anyhow::Result<()> {
+        let uuid = Uuid::new_v4();
+        let timestamp = Utc::now();
+
+        let op = Update {
+            uuid,
+            property: "abc".into(),
+            old_value: None,
+            value: None,
+            timestamp,
+        };
+
+        let json = serde_json::to_string(&op)?;
+        assert_eq!(
+            json,
+            format!(
+                r#"{{"Update":{{"uuid":"{}","property":"abc","old_value":null,"value":null,"timestamp":"{:?}"}}}}"#,
+                uuid, timestamp,
+            )
+        );
+        let deser: ReplicaOp = serde_json::from_str(&json)?;
+        assert_eq!(deser, op);
+        Ok(())
+    }
+
+    #[test]
+    fn test_into_sync_create() {
+        let uuid = Uuid::new_v4();
+        assert_eq!(Create { uuid }.into_sync(), Some(SyncOp::Create { uuid }));
+    }
+
+    #[test]
+    fn test_into_sync_delete() {
+        let uuid = Uuid::new_v4();
+        assert_eq!(
+            Delete {
+                uuid,
+                old_task: TaskMap::new()
+            }
+            .into_sync(),
+            Some(SyncOp::Delete { uuid })
+        );
+    }
+
+    #[test]
+    fn test_into_sync_update() {
+        let uuid = Uuid::new_v4();
+        let timestamp = Utc::now();
+        assert_eq!(
+            Update {
+                uuid,
+                property: "prop".into(),
+                old_value: Some("foo".into()),
+                value: Some("v".into()),
+                timestamp,
+            }
+            .into_sync(),
+            Some(SyncOp::Update {
+                uuid,
+                property: "prop".into(),
+                value: Some("v".into()),
+                timestamp,
+            })
+        );
+    }
+
+    #[test]
+    fn test_into_sync_undo_point() {
+        assert_eq!(UndoPoint.into_sync(), None);
+    }
+
+    #[test]
+    fn test_reverse_create() {
+        let uuid = Uuid::new_v4();
+        assert_eq!(Create { uuid }.reverse_ops(), vec![SyncOp::Delete { uuid }]);
+    }
+
+    #[test]
+    fn test_reverse_delete() {
+        let uuid = Uuid::new_v4();
+        let reversed = Delete {
+            uuid,
+            old_task: taskmap_with(vec![("prop1".into(), "v1".into())]),
+        }
+        .reverse_ops();
+        assert_eq!(reversed.len(), 2);
+        assert_eq!(reversed[0], SyncOp::Create { uuid });
+        assert!(matches!(
+            &reversed[1],
+            SyncOp::Update { uuid: u, property: p, value: Some(v), ..}
+                if u == &uuid && p == "prop1" && v == "v1"
+        ));
+    }
+
+    #[test]
+    fn test_reverse_update() {
+        let uuid = Uuid::new_v4();
+        let timestamp = Utc::now();
+        assert_eq!(
+            Update {
+                uuid,
+                property: "prop".into(),
+                old_value: Some("foo".into()),
+                value: Some("v".into()),
+                timestamp,
+            }
+            .reverse_ops(),
+            vec![SyncOp::Update {
+                uuid,
+                property: "prop".into(),
+                value: Some("foo".into()),
+                timestamp,
+            }]
+        );
+    }
+
+    #[test]
+    fn test_reverse_undo_point() {
+        assert_eq!(UndoPoint.reverse_ops(), vec![]);
+    }
+}

rust/taskchampion/src/storage/sqlite.rs

@@ -0,0 +1,810 @@
+use crate::storage::{ReplicaOp, Storage, StorageTxn, TaskMap, VersionId, DEFAULT_BASE_VERSION};
+use anyhow::Context;
+use rusqlite::types::{FromSql, ToSql};
+use rusqlite::{params, Connection, OptionalExtension};
+use std::path::Path;
+use uuid::Uuid;
+
+#[derive(Debug, thiserror::Error)]
+enum SqliteError {
+    #[error("SQLite transaction already committted")]
+    TransactionAlreadyCommitted,
+}
+
+/// Newtype to allow implementing `FromSql` for foreign `uuid::Uuid`
+pub(crate) struct StoredUuid(pub(crate) Uuid);
+
+/// Conversion from Uuid stored as a string (rusqlite's uuid feature stores as binary blob)
+impl FromSql for StoredUuid {
+    fn column_result(value: rusqlite::types::ValueRef<'_>) -> rusqlite::types::FromSqlResult<Self> {
+        let u = Uuid::parse_str(value.as_str()?)
+            .map_err(|_| rusqlite::types::FromSqlError::InvalidType)?;
+        Ok(StoredUuid(u))
+    }
+}
+
+/// Store Uuid as string in database
+impl ToSql for StoredUuid {
+    fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput<'_>> {
+        let s = self.0.to_string();
+        Ok(s.into())
+    }
+}
+
+/// Wraps [`TaskMap`] (type alias for HashMap) so we can implement rusqlite conversion traits for it
+struct StoredTaskMap(TaskMap);
+
+/// Parses TaskMap stored as JSON in string column
+impl FromSql for StoredTaskMap {
+    fn column_result(value: rusqlite::types::ValueRef<'_>) -> rusqlite::types::FromSqlResult<Self> {
+        let o: TaskMap = serde_json::from_str(value.as_str()?)
+            .map_err(|_| rusqlite::types::FromSqlError::InvalidType)?;
+        Ok(StoredTaskMap(o))
+    }
+}
+
+/// Stores TaskMap in string column
+impl ToSql for StoredTaskMap {
+    fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput<'_>> {
+        let s = serde_json::to_string(&self.0)
+            .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
+        Ok(s.into())
+    }
+}
+
+/// Stores [`ReplicaOp`] in SQLite
+impl FromSql for ReplicaOp {
+    fn column_result(value: rusqlite::types::ValueRef<'_>) -> rusqlite::types::FromSqlResult<Self> {
+        let o: ReplicaOp = serde_json::from_str(value.as_str()?)
+            .map_err(|_| rusqlite::types::FromSqlError::InvalidType)?;
+        Ok(o)
+    }
+}
+
+/// Parses ReplicaOp stored as JSON in string column
+impl ToSql for ReplicaOp {
+    fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput<'_>> {
+        let s = serde_json::to_string(&self)
+            .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
+        Ok(s.into())
+    }
+}
+
+/// SqliteStorage is an on-disk storage backed by SQLite3.
+pub struct SqliteStorage {
+    con: Connection,
+}
+
+impl SqliteStorage {
+    pub fn new<P: AsRef<Path>>(directory: P) -> anyhow::Result<SqliteStorage> {
+        // Ensure parent folder exists
+        std::fs::create_dir_all(&directory)?;
+
+        // Open (or create) database
+        let db_file = directory.as_ref().join("taskchampion.sqlite3");
+        let con = Connection::open(db_file)?;
+
+        // Initialize database
+        let queries = vec![
+            "CREATE TABLE IF NOT EXISTS operations (id INTEGER PRIMARY KEY AUTOINCREMENT, data STRING);",
+            "CREATE TABLE IF NOT EXISTS sync_meta (key STRING PRIMARY KEY, value STRING);",
+            "CREATE TABLE IF NOT EXISTS tasks (uuid STRING PRIMARY KEY, data STRING);",
+            "CREATE TABLE IF NOT EXISTS working_set (id INTEGER PRIMARY KEY, uuid STRING);",
+        ];
+        for q in queries {
+            con.execute(q, []).context("Creating table")?;
+        }
+
+        Ok(SqliteStorage { con })
+    }
+}
+
+struct Txn<'t> {
+    txn: Option<rusqlite::Transaction<'t>>,
+}
+
+impl<'t> Txn<'t> {
+    fn get_txn(&self) -> Result<&rusqlite::Transaction<'t>, SqliteError> {
+        self.txn
+            .as_ref()
+            .ok_or(SqliteError::TransactionAlreadyCommitted)
+    }
+
+    fn get_next_working_set_number(&self) -> anyhow::Result<usize> {
+        let t = self.get_txn()?;
+        let next_id: Option<usize> = t
+            .query_row(
+                "SELECT COALESCE(MAX(id), 0) + 1 FROM working_set",
+                [],
+                |r| r.get(0),
+            )
+            .optional()
+            .context("Getting highest working set ID")?;
+
+        Ok(next_id.unwrap_or(0))
+    }
+}
+
+impl Storage for SqliteStorage {
+    fn txn<'a>(&'a mut self) -> anyhow::Result<Box<dyn StorageTxn + 'a>> {
+        let txn = self.con.transaction()?;
+        Ok(Box::new(Txn { txn: Some(txn) }))
+    }
+}
+
+impl<'t> StorageTxn for Txn<'t> {
+    fn get_task(&mut self, uuid: Uuid) -> anyhow::Result<Option<TaskMap>> {
+        let t = self.get_txn()?;
+        let result: Option<StoredTaskMap> = t
+            .query_row(
+                "SELECT data FROM tasks WHERE uuid = ? LIMIT 1",
+                [&StoredUuid(uuid)],
+                |r| r.get("data"),
+            )
+            .optional()?;
+
+        // Get task from "stored" wrapper
+        Ok(result.map(|t| t.0))
+    }
+
+    fn create_task(&mut self, uuid: Uuid) -> anyhow::Result<bool> {
+        let t = self.get_txn()?;
+        let count: usize = t.query_row(
+            "SELECT count(uuid) FROM tasks WHERE uuid = ?",
+            [&StoredUuid(uuid)],
+            |x| x.get(0),
+        )?;
+        if count > 0 {
+            return Ok(false);
+        }
+
+        let data = TaskMap::default();
+        t.execute(
+            "INSERT INTO tasks (uuid, data) VALUES (?, ?)",
+            params![&StoredUuid(uuid), &StoredTaskMap(data)],
+        )
+        .context("Create task query")?;
+        Ok(true)
+    }
+
+    fn set_task(&mut self, uuid: Uuid, task: TaskMap) -> anyhow::Result<()> {
+        let t = self.get_txn()?;
+        t.execute(
+            "INSERT OR REPLACE INTO tasks (uuid, data) VALUES (?, ?)",
+            params![&StoredUuid(uuid), &StoredTaskMap(task)],
+        )
+        .context("Update task query")?;
+        Ok(())
+    }
+
+    fn delete_task(&mut self, uuid: Uuid) -> anyhow::Result<bool> {
+        let t = self.get_txn()?;
+        let changed = t
+            .execute("DELETE FROM tasks WHERE uuid = ?", [&StoredUuid(uuid)])
+            .context("Delete task query")?;
+        Ok(changed > 0)
+    }
+
+    fn all_tasks(&mut self) -> anyhow::Result<Vec<(Uuid, TaskMap)>> {
+        let t = self.get_txn()?;
+
+        let mut q = t.prepare("SELECT uuid, data FROM tasks")?;
+        let rows = q.query_map([], |r| {
+            let uuid: StoredUuid = r.get("uuid")?;
+            let data: StoredTaskMap = r.get("data")?;
+            Ok((uuid.0, data.0))
+        })?;
+
+        let mut ret = vec![];
+        for r in rows {
+            ret.push(r?);
+        }
+        Ok(ret)
+    }
+
+    fn all_task_uuids(&mut self) -> anyhow::Result<Vec<Uuid>> {
+        let t = self.get_txn()?;
+
+        let mut q = t.prepare("SELECT uuid FROM tasks")?;
+        let rows = q.query_map([], |r| {
+            let uuid: StoredUuid = r.get("uuid")?;
+            Ok(uuid.0)
+        })?;
+
+        let mut ret = vec![];
+        for r in rows {
+            ret.push(r?);
+        }
+        Ok(ret)
+    }
+
+    fn base_version(&mut self) -> anyhow::Result<VersionId> {
+        let t = self.get_txn()?;
+
+        let version: Option<StoredUuid> = t
+            .query_row(
+                "SELECT value FROM sync_meta WHERE key = 'base_version'",
+                [],
+                |r| r.get("value"),
+            )
+            .optional()?;
+        Ok(version.map(|u| u.0).unwrap_or(DEFAULT_BASE_VERSION))
+    }
+
+    fn set_base_version(&mut self, version: VersionId) -> anyhow::Result<()> {
+        let t = self.get_txn()?;
+        t.execute(
+            "INSERT OR REPLACE INTO sync_meta (key, value) VALUES (?, ?)",
+            params!["base_version", &StoredUuid(version)],
+        )
+        .context("Set base version")?;
+        Ok(())
+    }
+
+    fn operations(&mut self) -> anyhow::Result<Vec<ReplicaOp>> {
+        let t = self.get_txn()?;
+
+        let mut q = t.prepare("SELECT data FROM operations ORDER BY id ASC")?;
+        let rows = q.query_map([], |r| {
+            let data: ReplicaOp = r.get("data")?;
+            Ok(data)
+        })?;
+
+        let mut ret = vec![];
+        for r in rows {
+            ret.push(r?);
+        }
+        Ok(ret)
+    }
+
+    fn num_operations(&mut self) -> anyhow::Result<usize> {
+        let t = self.get_txn()?;
+        let count: usize = t.query_row("SELECT count(*) FROM operations", [], |x| x.get(0))?;
+        Ok(count)
+    }
+
+    fn add_operation(&mut self, op: ReplicaOp) -> anyhow::Result<()> {
+        let t = self.get_txn()?;
+
+        t.execute("INSERT INTO operations (data) VALUES (?)", params![&op])
+            .context("Add operation query")?;
+        Ok(())
+    }
+
+    fn set_operations(&mut self, ops: Vec<ReplicaOp>) -> anyhow::Result<()> {
+        let t = self.get_txn()?;
+        t.execute("DELETE FROM operations", [])
+            .context("Clear all existing operations")?;
+        t.execute("DELETE FROM sqlite_sequence WHERE name = 'operations'", [])
+            .context("Clear all existing operations")?;
+
+        for o in ops {
+            self.add_operation(o)?;
+        }
+        Ok(())
+    }
+
+    fn get_working_set(&mut self) -> anyhow::Result<Vec<Option<Uuid>>> {
+        let t = self.get_txn()?;
+
+        let mut q = t.prepare("SELECT id, uuid FROM working_set ORDER BY id ASC")?;
+        let rows = q
+            .query_map([], |r| {
+                let id: usize = r.get("id")?;
+                let uuid: StoredUuid = r.get("uuid")?;
+                Ok((id, uuid.0))
+            })
+            .context("Get working set query")?;
+
+        let rows: Vec<Result<(usize, Uuid), _>> = rows.collect();
+        let mut res = Vec::with_capacity(rows.len());
+        for _ in 0..self
+            .get_next_working_set_number()
+            .context("Getting working set number")?
+        {
+            res.push(None);
+        }
+        for r in rows {
+            let (id, uuid) = r?;
+            res[id as usize] = Some(uuid);
+        }
+
+        Ok(res)
+    }
+
+    fn add_to_working_set(&mut self, uuid: Uuid) -> anyhow::Result<usize> {
+        let t = self.get_txn()?;
+
+        let next_working_id = self.get_next_working_set_number()?;
+
+        t.execute(
+            "INSERT INTO working_set (id, uuid) VALUES (?, ?)",
+            params![next_working_id, &StoredUuid(uuid)],
+        )
+        .context("Create task query")?;
+
+        Ok(next_working_id)
+    }
+
+    fn set_working_set_item(&mut self, index: usize, uuid: Option<Uuid>) -> anyhow::Result<()> {
+        let t = self.get_txn()?;
+        match uuid {
+            // Add or override item
+            Some(uuid) => t.execute(
+                "INSERT OR REPLACE INTO working_set (id, uuid) VALUES (?, ?)",
+                params![index, &StoredUuid(uuid)],
+            ),
+            // Setting to None removes the row from database
+            None => t.execute("DELETE FROM working_set WHERE id = ?", [index]),
+        }
+        .context("Set working set item query")?;
+        Ok(())
+    }
+
+    fn clear_working_set(&mut self) -> anyhow::Result<()> {
+        let t = self.get_txn()?;
+        t.execute("DELETE FROM working_set", [])
+            .context("Clear working set query")?;
+        Ok(())
+    }
+
+    fn commit(&mut self) -> anyhow::Result<()> {
+        let t = self
+            .txn
+            .take()
+            .ok_or(SqliteError::TransactionAlreadyCommitted)?;
+        t.commit().context("Committing transaction")?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::storage::taskmap_with;
+    use pretty_assertions::assert_eq;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_empty_dir() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let non_existant = tmp_dir.path().join("subdir");
+        let mut storage = SqliteStorage::new(&non_existant)?;
+        let uuid = Uuid::new_v4();
+        {
+            let mut txn = storage.txn()?;
+            assert!(txn.create_task(uuid)?);
+            txn.commit()?;
+        }
+        {
+            let mut txn = storage.txn()?;
+            let task = txn.get_task(uuid)?;
+            assert_eq!(task, Some(taskmap_with(vec![])));
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn drop_transaction() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        let uuid1 = Uuid::new_v4();
+        let uuid2 = Uuid::new_v4();
+
+        {
+            let mut txn = storage.txn()?;
+            assert!(txn.create_task(uuid1)?);
+            txn.commit()?;
+        }
+
+        {
+            let mut txn = storage.txn()?;
+            assert!(txn.create_task(uuid2)?);
+            std::mem::drop(txn); // Unnecessary explicit drop of transaction
+        }
+
+        {
+            let mut txn = storage.txn()?;
+            let uuids = txn.all_task_uuids()?;
+
+            assert_eq!(uuids, [uuid1]);
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_create() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        let uuid = Uuid::new_v4();
+        {
+            let mut txn = storage.txn()?;
+            assert!(txn.create_task(uuid)?);
+            txn.commit()?;
+        }
+        {
+            let mut txn = storage.txn()?;
+            let task = txn.get_task(uuid)?;
+            assert_eq!(task, Some(taskmap_with(vec![])));
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_create_exists() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        let uuid = Uuid::new_v4();
+        {
+            let mut txn = storage.txn()?;
+            assert!(txn.create_task(uuid)?);
+            txn.commit()?;
+        }
+        {
+            let mut txn = storage.txn()?;
+            assert!(!txn.create_task(uuid)?);
+            txn.commit()?;
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_get_missing() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        let uuid = Uuid::new_v4();
+        {
+            let mut txn = storage.txn()?;
+            let task = txn.get_task(uuid)?;
+            assert_eq!(task, None);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_set_task() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        let uuid = Uuid::new_v4();
+        {
+            let mut txn = storage.txn()?;
+            txn.set_task(uuid, taskmap_with(vec![("k".to_string(), "v".to_string())]))?;
+            txn.commit()?;
+        }
+        {
+            let mut txn = storage.txn()?;
+            let task = txn.get_task(uuid)?;
+            assert_eq!(
+                task,
+                Some(taskmap_with(vec![("k".to_string(), "v".to_string())]))
+            );
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_delete_task_missing() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        let uuid = Uuid::new_v4();
+        {
+            let mut txn = storage.txn()?;
+            assert!(!txn.delete_task(uuid)?);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_delete_task_exists() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        let uuid = Uuid::new_v4();
+        {
+            let mut txn = storage.txn()?;
+            assert!(txn.create_task(uuid)?);
+            txn.commit()?;
+        }
+        {
+            let mut txn = storage.txn()?;
+            assert!(txn.delete_task(uuid)?);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_all_tasks_empty() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        {
+            let mut txn = storage.txn()?;
+            let tasks = txn.all_tasks()?;
+            assert_eq!(tasks, vec![]);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_all_tasks_and_uuids() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        let uuid1 = Uuid::new_v4();
+        let uuid2 = Uuid::new_v4();
+        {
+            let mut txn = storage.txn()?;
+            assert!(txn.create_task(uuid1.clone())?);
+            txn.set_task(
+                uuid1.clone(),
+                taskmap_with(vec![("num".to_string(), "1".to_string())]),
+            )?;
+            assert!(txn.create_task(uuid2.clone())?);
+            txn.set_task(
+                uuid2.clone(),
+                taskmap_with(vec![("num".to_string(), "2".to_string())]),
+            )?;
+            txn.commit()?;
+        }
+        {
+            let mut txn = storage.txn()?;
+            let mut tasks = txn.all_tasks()?;
+
+            // order is nondeterministic, so sort by uuid
+            tasks.sort_by(|a, b| a.0.cmp(&b.0));
+
+            let mut exp = vec![
+                (
+                    uuid1.clone(),
+                    taskmap_with(vec![("num".to_string(), "1".to_string())]),
+                ),
+                (
+                    uuid2.clone(),
+                    taskmap_with(vec![("num".to_string(), "2".to_string())]),
+                ),
+            ];
+            exp.sort_by(|a, b| a.0.cmp(&b.0));
+
+            assert_eq!(tasks, exp);
+        }
+        {
+            let mut txn = storage.txn()?;
+            let mut uuids = txn.all_task_uuids()?;
+            uuids.sort();
+
+            let mut exp = vec![uuid1.clone(), uuid2.clone()];
+            exp.sort();
+
+            assert_eq!(uuids, exp);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_base_version_default() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        {
+            let mut txn = storage.txn()?;
+            assert_eq!(txn.base_version()?, DEFAULT_BASE_VERSION);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_base_version_setting() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        let u = Uuid::new_v4();
+        {
+            let mut txn = storage.txn()?;
+            txn.set_base_version(u)?;
+            txn.commit()?;
+        }
+        {
+            let mut txn = storage.txn()?;
+            assert_eq!(txn.base_version()?, u);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_operations() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        let uuid1 = Uuid::new_v4();
+        let uuid2 = Uuid::new_v4();
+        let uuid3 = Uuid::new_v4();
+
+        // create some operations
+        {
+            let mut txn = storage.txn()?;
+            txn.add_operation(ReplicaOp::Create { uuid: uuid1 })?;
+            txn.add_operation(ReplicaOp::Create { uuid: uuid2 })?;
+            txn.commit()?;
+        }
+
+        // read them back
+        {
+            let mut txn = storage.txn()?;
+            let ops = txn.operations()?;
+            assert_eq!(
+                ops,
+                vec![
+                    ReplicaOp::Create { uuid: uuid1 },
+                    ReplicaOp::Create { uuid: uuid2 },
+                ]
+            );
+
+            assert_eq!(txn.num_operations()?, 2);
+        }
+
+        // set them to a different bunch
+        {
+            let mut txn = storage.txn()?;
+            txn.set_operations(vec![
+                ReplicaOp::Delete {
+                    uuid: uuid2,
+                    old_task: TaskMap::new(),
+                },
+                ReplicaOp::Delete {
+                    uuid: uuid1,
+                    old_task: TaskMap::new(),
+                },
+            ])?;
+            txn.commit()?;
+        }
+
+        // create some more operations (to test adding operations after clearing)
+        {
+            let mut txn = storage.txn()?;
+            txn.add_operation(ReplicaOp::Create { uuid: uuid3 })?;
+            txn.add_operation(ReplicaOp::Delete {
+                uuid: uuid3,
+                old_task: TaskMap::new(),
+            })?;
+            txn.commit()?;
+        }
+
+        // read them back
+        {
+            let mut txn = storage.txn()?;
+            let ops = txn.operations()?;
+            assert_eq!(
+                ops,
+                vec![
+                    ReplicaOp::Delete {
+                        uuid: uuid2,
+                        old_task: TaskMap::new()
+                    },
+                    ReplicaOp::Delete {
+                        uuid: uuid1,
+                        old_task: TaskMap::new()
+                    },
+                    ReplicaOp::Create { uuid: uuid3 },
+                    ReplicaOp::Delete {
+                        uuid: uuid3,
+                        old_task: TaskMap::new()
+                    },
+                ]
+            );
+            assert_eq!(txn.num_operations()?, 4);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn get_working_set_empty() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+
+        {
+            let mut txn = storage.txn()?;
+            let ws = txn.get_working_set()?;
+            assert_eq!(ws, vec![None]);
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn add_to_working_set() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        let uuid1 = Uuid::new_v4();
+        let uuid2 = Uuid::new_v4();
+
+        {
+            let mut txn = storage.txn()?;
+            txn.add_to_working_set(uuid1)?;
+            txn.add_to_working_set(uuid2)?;
+            txn.commit()?;
+        }
+
+        {
+            let mut txn = storage.txn()?;
+            let ws = txn.get_working_set()?;
+            assert_eq!(ws, vec![None, Some(uuid1), Some(uuid2)]);
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn clear_working_set() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        let uuid1 = Uuid::new_v4();
+        let uuid2 = Uuid::new_v4();
+
+        {
+            let mut txn = storage.txn()?;
+            txn.add_to_working_set(uuid1)?;
+            txn.add_to_working_set(uuid2)?;
+            txn.commit()?;
+        }
+
+        {
+            let mut txn = storage.txn()?;
+            txn.clear_working_set()?;
+            txn.add_to_working_set(uuid2)?;
+            txn.add_to_working_set(uuid1)?;
+            txn.commit()?;
+        }
+
+        {
+            let mut txn = storage.txn()?;
+            let ws = txn.get_working_set()?;
+            assert_eq!(ws, vec![None, Some(uuid2), Some(uuid1)]);
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn set_working_set_item() -> anyhow::Result<()> {
+        let tmp_dir = TempDir::new()?;
+        let mut storage = SqliteStorage::new(&tmp_dir.path())?;
+        let uuid1 = Uuid::new_v4();
+        let uuid2 = Uuid::new_v4();
+
+        {
+            let mut txn = storage.txn()?;
+            txn.add_to_working_set(uuid1)?;
+            txn.add_to_working_set(uuid2)?;
+            txn.commit()?;
+        }
+
+        {
+            let mut txn = storage.txn()?;
+            let ws = txn.get_working_set()?;
+            assert_eq!(ws, vec![None, Some(uuid1), Some(uuid2)]);
+        }
+
+        // Clear one item
+        {
+            let mut txn = storage.txn()?;
+            txn.set_working_set_item(1, None)?;
+            txn.commit()?;
+        }
+
+        {
+            let mut txn = storage.txn()?;
+            let ws = txn.get_working_set()?;
+            assert_eq!(ws, vec![None, None, Some(uuid2)]);
+        }
+
+        // Override item
+        {
+            let mut txn = storage.txn()?;
+            txn.set_working_set_item(2, Some(uuid1))?;
+            txn.commit()?;
+        }
+
+        {
+            let mut txn = storage.txn()?;
+            let ws = txn.get_working_set()?;
+            assert_eq!(ws, vec![None, None, Some(uuid1)]);
+        }
+
+        Ok(())
+    }
+}