787 lines
23 KiB
Rust
787 lines
23 KiB
Rust
use crate::replica::Replica;
|
|
use crate::storage::TaskMap;
|
|
use chrono::prelude::*;
|
|
use log::trace;
|
|
use std::convert::AsRef;
|
|
use std::convert::{TryFrom, TryInto};
|
|
use std::fmt;
|
|
use std::str::FromStr;
|
|
use uuid::Uuid;
|
|
|
|
pub type Timestamp = DateTime<Utc>;
|
|
|
|
/// The priority of a task
|
|
#[derive(Debug, PartialEq)]
|
|
pub enum Priority {
|
|
/// Low
|
|
L,
|
|
/// Medium
|
|
M,
|
|
/// High
|
|
H,
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
impl Priority {
|
|
/// Get a Priority from the 1-character value in a TaskMap,
|
|
/// defaulting to M
|
|
pub(crate) fn from_taskmap(s: &str) -> Priority {
|
|
match s {
|
|
"L" => Priority::L,
|
|
"M" => Priority::M,
|
|
"H" => Priority::H,
|
|
_ => Priority::M,
|
|
}
|
|
}
|
|
|
|
/// Get the 1-character value for this priority to use in the TaskMap.
|
|
pub(crate) fn to_taskmap(&self) -> &str {
|
|
match self {
|
|
Priority::L => "L",
|
|
Priority::M => "M",
|
|
Priority::H => "H",
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The status of a task. The default status in "Pending".
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub enum Status {
|
|
Pending,
|
|
Completed,
|
|
Deleted,
|
|
}
|
|
|
|
impl Status {
|
|
/// Get a Status from the 1-character value in a TaskMap,
|
|
/// defaulting to Pending
|
|
pub(crate) fn from_taskmap(s: &str) -> Status {
|
|
match s {
|
|
"P" => Status::Pending,
|
|
"C" => Status::Completed,
|
|
"D" => Status::Deleted,
|
|
_ => Status::Pending,
|
|
}
|
|
}
|
|
|
|
/// Get the 1-character value for this status to use in the TaskMap.
|
|
pub(crate) fn to_taskmap(&self) -> &str {
|
|
match self {
|
|
Status::Pending => "P",
|
|
Status::Completed => "C",
|
|
Status::Deleted => "D",
|
|
}
|
|
}
|
|
|
|
/// Get the full-name value for this status to use in the TaskMap.
|
|
pub fn to_string(&self) -> &str {
|
|
// TODO: should be impl Display
|
|
match self {
|
|
Status::Pending => "Pending",
|
|
Status::Completed => "Completed",
|
|
Status::Deleted => "Deleted",
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: separate module, wrap in newtype to avoid pub details
|
|
/// A Tag is a descriptor for a task, that is either present or absent, and can be used for
|
|
/// filtering. Tags composed of all uppercase letters are reserved for synthetic tags.
|
|
///
|
|
/// Valid tags must not contain whitespace or any of the characters in [`INVALID_TAG_CHARACTERS`].
|
|
/// The first characters additionally cannot be a digit, and subsequent characters cannot be `:`.
|
|
/// This definition is based on [that of
|
|
/// TaskWarrior](https://github.com/GothenburgBitFactory/taskwarrior/blob/663c6575ceca5bd0135ae884879339dac89d3142/src/Lexer.cpp#L146-L164).
|
|
#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
|
|
// TODO: impl Default
|
|
pub enum Tag {
|
|
User(String),
|
|
Synthetic(SyntheticTag),
|
|
}
|
|
|
|
pub const INVALID_TAG_CHARACTERS: &str = "+-*/(<>^! %=~";
|
|
|
|
impl Tag {
|
|
fn from_str(value: &str) -> Result<Tag, anyhow::Error> {
|
|
fn err(value: &str) -> Result<Tag, anyhow::Error> {
|
|
anyhow::bail!("invalid tag {:?}", value)
|
|
}
|
|
|
|
// first, look for synthetic tags
|
|
if value.chars().all(|c| c.is_ascii_uppercase()) {
|
|
if let Ok(st) = SyntheticTag::from_str(value) {
|
|
return Ok(Self::Synthetic(st));
|
|
}
|
|
// all uppercase, but not a valid synthetic tag
|
|
return err(value);
|
|
}
|
|
|
|
if let Some(c) = value.chars().next() {
|
|
if c.is_whitespace() || c.is_ascii_digit() || INVALID_TAG_CHARACTERS.contains(c) {
|
|
return err(value);
|
|
}
|
|
} else {
|
|
return err(value);
|
|
}
|
|
if !value
|
|
.chars()
|
|
.skip(1)
|
|
.all(|c| !(c.is_whitespace() || c == ':' || INVALID_TAG_CHARACTERS.contains(c)))
|
|
{
|
|
return err(value);
|
|
}
|
|
Ok(Self::User(String::from(value)))
|
|
}
|
|
}
|
|
|
|
impl TryFrom<&str> for Tag {
|
|
type Error = anyhow::Error;
|
|
|
|
fn try_from(value: &str) -> Result<Tag, Self::Error> {
|
|
Self::from_str(value)
|
|
}
|
|
}
|
|
|
|
impl TryFrom<&String> for Tag {
|
|
type Error = anyhow::Error;
|
|
|
|
fn try_from(value: &String) -> Result<Tag, Self::Error> {
|
|
Self::from_str(&value[..])
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Tag {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
Self::User(s) => s.fmt(f),
|
|
Self::Synthetic(st) => st.as_ref().fmt(f),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl AsRef<str> for Tag {
|
|
fn as_ref(&self) -> &str {
|
|
match self {
|
|
Self::User(s) => s.as_ref(),
|
|
Self::Synthetic(st) => st.as_ref(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(
|
|
Debug,
|
|
Clone,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Hash,
|
|
strum_macros::EnumString,
|
|
strum_macros::AsRefStr,
|
|
strum_macros::EnumIter,
|
|
)]
|
|
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
|
|
pub enum SyntheticTag {
|
|
Waiting,
|
|
Active,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
pub struct Annotation {
|
|
pub entry: Timestamp,
|
|
pub description: String,
|
|
}
|
|
|
|
/// A task, as publicly exposed by this crate.
|
|
///
|
|
/// Note that Task objects represent a snapshot of the task at a moment in time, and are not
|
|
/// protected by the atomicity of the backend storage. Concurrent modifications are safe,
|
|
/// but a Task that is cached for more than a few seconds may cause the user to see stale
|
|
/// data. Fetch, use, and drop Tasks quickly.
|
|
///
|
|
/// This struct contains only getters for various values on the task. The `into_mut` method returns
|
|
/// a TaskMut which can be used to modify the task.
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub struct Task {
|
|
uuid: Uuid,
|
|
taskmap: TaskMap,
|
|
}
|
|
|
|
/// A mutable task, with setter methods. Most methods are simple setters and not further
|
|
/// described. Calling a setter will update the Replica, as well as the included Task.
|
|
pub struct TaskMut<'r> {
|
|
task: Task,
|
|
replica: &'r mut Replica,
|
|
updated_modified: bool,
|
|
}
|
|
|
|
impl Task {
|
|
pub(crate) fn new(uuid: Uuid, taskmap: TaskMap) -> Task {
|
|
Task { uuid, taskmap }
|
|
}
|
|
|
|
pub fn get_uuid(&self) -> Uuid {
|
|
self.uuid
|
|
}
|
|
|
|
pub fn get_taskmap(&self) -> &TaskMap {
|
|
&self.taskmap
|
|
}
|
|
|
|
/// Prepare to mutate this task, requiring a mutable Replica
|
|
/// in order to update the data it contains.
|
|
pub fn into_mut(self, replica: &mut Replica) -> TaskMut {
|
|
TaskMut {
|
|
task: self,
|
|
replica,
|
|
updated_modified: false,
|
|
}
|
|
}
|
|
|
|
pub fn get_status(&self) -> Status {
|
|
self.taskmap
|
|
.get("status")
|
|
.map(|s| Status::from_taskmap(s))
|
|
.unwrap_or(Status::Pending)
|
|
}
|
|
|
|
pub fn get_description(&self) -> &str {
|
|
self.taskmap
|
|
.get("description")
|
|
.map(|s| s.as_ref())
|
|
.unwrap_or("")
|
|
}
|
|
|
|
/// Get the wait time. If this value is set, it will be returned, even
|
|
/// if it is in the past.
|
|
pub fn get_wait(&self) -> Option<DateTime<Utc>> {
|
|
self.get_timestamp("wait")
|
|
}
|
|
|
|
/// Determine whether this task is waiting now.
|
|
pub fn is_waiting(&self) -> bool {
|
|
if let Some(ts) = self.get_wait() {
|
|
return ts > Utc::now();
|
|
}
|
|
false
|
|
}
|
|
|
|
/// Determine whether this task is active -- that is, that it has been started
|
|
/// and not stopped.
|
|
pub fn is_active(&self) -> bool {
|
|
self.taskmap
|
|
.iter()
|
|
.any(|(k, v)| k.starts_with("start.") && v.is_empty())
|
|
}
|
|
|
|
/// Determine whether a given synthetic tag is present on this task. All other
|
|
/// synthetic tag calculations are based on this one.
|
|
fn has_synthetic_tag(&self, synth: &SyntheticTag) -> bool {
|
|
match synth {
|
|
SyntheticTag::Waiting => self.is_waiting(),
|
|
SyntheticTag::Active => self.is_active(),
|
|
}
|
|
}
|
|
|
|
/// Check if this task has the given tag
|
|
pub fn has_tag(&self, tag: &Tag) -> bool {
|
|
match tag {
|
|
Tag::User(s) => self.taskmap.contains_key(&format!("tag.{}", s)),
|
|
Tag::Synthetic(st) => self.has_synthetic_tag(st),
|
|
}
|
|
}
|
|
|
|
/// Iterate over the task's tags
|
|
pub fn get_tags(&self) -> impl Iterator<Item = Tag> + '_ {
|
|
use strum::IntoEnumIterator;
|
|
|
|
self.taskmap
|
|
.iter()
|
|
.filter_map(|(k, _)| {
|
|
if let Some(tag) = k.strip_prefix("tag.") {
|
|
if let Ok(tag) = tag.try_into() {
|
|
return Some(tag);
|
|
}
|
|
// note that invalid "tag.*" are ignored
|
|
}
|
|
None
|
|
})
|
|
.chain(
|
|
SyntheticTag::iter()
|
|
.filter(move |st| self.has_synthetic_tag(st))
|
|
.map(|st| Tag::Synthetic(st)),
|
|
)
|
|
}
|
|
|
|
pub fn get_modified(&self) -> Option<DateTime<Utc>> {
|
|
self.get_timestamp("modified")
|
|
}
|
|
|
|
// -- utility functions
|
|
|
|
fn get_timestamp(&self, property: &str) -> Option<DateTime<Utc>> {
|
|
if let Some(ts) = self.taskmap.get(property) {
|
|
if let Ok(ts) = ts.parse() {
|
|
return Some(Utc.timestamp(ts, 0));
|
|
}
|
|
// if the value does not parse as an integer, default to None
|
|
}
|
|
None
|
|
}
|
|
}
|
|
|
|
impl<'r> TaskMut<'r> {
|
|
/// Get the immutable version of this object. Note that TaskMut [`std::ops::Deref`]s to
|
|
/// [`crate::task::Task`], so all of that struct's getter methods can be used on TaskMut.
|
|
pub fn into_immut(self) -> Task {
|
|
self.task
|
|
}
|
|
|
|
/// Set the task's status. This also adds the task to the working set if the
|
|
/// new status puts it in that set.
|
|
pub fn set_status(&mut self, status: Status) -> anyhow::Result<()> {
|
|
if status == Status::Pending {
|
|
let uuid = self.uuid;
|
|
self.replica.add_to_working_set(uuid)?;
|
|
}
|
|
self.set_string("status", Some(String::from(status.to_taskmap())))
|
|
}
|
|
|
|
pub fn set_description(&mut self, description: String) -> anyhow::Result<()> {
|
|
self.set_string("description", Some(description))
|
|
}
|
|
|
|
pub fn set_wait(&mut self, wait: Option<DateTime<Utc>>) -> anyhow::Result<()> {
|
|
self.set_timestamp("wait", wait)
|
|
}
|
|
|
|
pub fn set_modified(&mut self, modified: DateTime<Utc>) -> anyhow::Result<()> {
|
|
self.set_timestamp("modified", Some(modified))
|
|
}
|
|
|
|
/// Start the task by creating "start.<timestamp": "", if the task is not already
|
|
/// active.
|
|
pub fn start(&mut self) -> anyhow::Result<()> {
|
|
if self.is_active() {
|
|
return Ok(());
|
|
}
|
|
let k = format!("start.{}", Utc::now().timestamp());
|
|
self.set_string(k, Some(String::from("")))
|
|
}
|
|
|
|
/// Stop the task by adding the current timestamp to all un-resolved "start.<timestamp>" keys.
|
|
pub fn stop(&mut self) -> anyhow::Result<()> {
|
|
let keys = self
|
|
.taskmap
|
|
.iter()
|
|
.filter(|(k, v)| k.starts_with("start.") && v.is_empty())
|
|
.map(|(k, _)| k)
|
|
.cloned()
|
|
.collect::<Vec<_>>();
|
|
let now = Utc::now();
|
|
for key in keys {
|
|
println!("{}", key);
|
|
self.set_timestamp(&key, Some(now))?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Add a tag to this task. Does nothing if the tag is already present.
|
|
pub fn add_tag(&mut self, tag: &Tag) -> anyhow::Result<()> {
|
|
if let Tag::Synthetic(_) = tag {
|
|
anyhow::bail!("Synthetic tags cannot be modified");
|
|
}
|
|
self.set_string(format!("tag.{}", tag), Some("".to_owned()))
|
|
}
|
|
|
|
/// Remove a tag from this task. Does nothing if the tag is not present.
|
|
pub fn remove_tag(&mut self, tag: &Tag) -> anyhow::Result<()> {
|
|
if let Tag::Synthetic(_) = tag {
|
|
anyhow::bail!("Synthetic tags cannot be modified");
|
|
}
|
|
self.set_string(format!("tag.{}", tag), None)
|
|
}
|
|
|
|
// -- utility functions
|
|
|
|
fn lastmod(&mut self) -> anyhow::Result<()> {
|
|
if !self.updated_modified {
|
|
let now = format!("{}", Utc::now().timestamp());
|
|
self.replica
|
|
.update_task(self.task.uuid, "modified", Some(now.clone()))?;
|
|
trace!("task {}: set property modified={:?}", self.task.uuid, now);
|
|
self.task.taskmap.insert(String::from("modified"), now);
|
|
self.updated_modified = true;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn set_string<S: Into<String>>(
|
|
&mut self,
|
|
property: S,
|
|
value: Option<String>,
|
|
) -> anyhow::Result<()> {
|
|
let property = property.into();
|
|
self.lastmod()?;
|
|
self.replica
|
|
.update_task(self.task.uuid, &property, value.as_ref())?;
|
|
|
|
if let Some(v) = value {
|
|
trace!("task {}: set property {}={:?}", self.task.uuid, property, v);
|
|
self.task.taskmap.insert(property, v);
|
|
} else {
|
|
trace!("task {}: remove property {}", self.task.uuid, property);
|
|
self.task.taskmap.remove(&property);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn set_timestamp(
|
|
&mut self,
|
|
property: &str,
|
|
value: Option<DateTime<Utc>>,
|
|
) -> anyhow::Result<()> {
|
|
self.lastmod()?;
|
|
if let Some(value) = value {
|
|
let ts = format!("{}", value.timestamp());
|
|
self.replica
|
|
.update_task(self.task.uuid, property, Some(ts.clone()))?;
|
|
self.task.taskmap.insert(property.to_string(), ts);
|
|
} else {
|
|
self.replica
|
|
.update_task::<_, &str>(self.task.uuid, property, None)?;
|
|
self.task.taskmap.remove(property);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Used by tests to ensure that updates are properly written
|
|
#[cfg(test)]
|
|
fn reload(&mut self) -> anyhow::Result<()> {
|
|
let uuid = self.uuid;
|
|
let task = self.replica.get_task(uuid)?.unwrap();
|
|
self.task.taskmap = task.taskmap;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl<'r> std::ops::Deref for TaskMut<'r> {
|
|
type Target = Task;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.task
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
use rstest::rstest;
|
|
|
|
fn with_mut_task<F: FnOnce(TaskMut)>(f: F) {
|
|
let mut replica = Replica::new_inmemory();
|
|
let task = replica.new_task(Status::Pending, "test".into()).unwrap();
|
|
let task = task.into_mut(&mut replica);
|
|
f(task)
|
|
}
|
|
|
|
/// Create a user tag, without checking its validity
|
|
fn utag(name: &'static str) -> Tag {
|
|
Tag::User(name.into())
|
|
}
|
|
|
|
/// Create a synthetic tag
|
|
fn stag(synth: SyntheticTag) -> Tag {
|
|
Tag::Synthetic(synth)
|
|
}
|
|
|
|
#[rstest]
|
|
#[case::simple("abc")]
|
|
#[case::colon_prefix(":abc")]
|
|
#[case::letters_and_numbers("a123_456")]
|
|
#[case::synthetic("WAITING")]
|
|
fn test_tag_try_into_success(#[case] s: &'static str) {
|
|
let tag: Tag = s.try_into().unwrap();
|
|
// check Display (via to_string) and AsRef while we're here
|
|
assert_eq!(tag.to_string(), s.to_owned());
|
|
assert_eq!(tag.as_ref(), s);
|
|
}
|
|
|
|
#[rstest]
|
|
#[case::empty("")]
|
|
#[case::colon_infix("a:b")]
|
|
#[case::digits("999")]
|
|
#[case::bangs("abc!!!")]
|
|
#[case::no_such_synthetic("NOSUCH")]
|
|
fn test_tag_try_into_err(#[case] s: &'static str) {
|
|
let tag: Result<Tag, _> = s.try_into();
|
|
assert_eq!(
|
|
tag.unwrap_err().to_string(),
|
|
format!("invalid tag \"{}\"", s)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_is_active_never_started() {
|
|
let task = Task::new(Uuid::new_v4(), TaskMap::new());
|
|
assert!(!task.is_active());
|
|
}
|
|
|
|
#[test]
|
|
fn test_is_active() {
|
|
let task = Task::new(
|
|
Uuid::new_v4(),
|
|
vec![(String::from("start.1234"), String::from(""))]
|
|
.drain(..)
|
|
.collect(),
|
|
);
|
|
|
|
assert!(task.is_active());
|
|
}
|
|
|
|
#[test]
|
|
fn test_is_active_stopped() {
|
|
let task = Task::new(
|
|
Uuid::new_v4(),
|
|
vec![(String::from("start.1234"), String::from("1235"))]
|
|
.drain(..)
|
|
.collect(),
|
|
);
|
|
|
|
assert!(!task.is_active());
|
|
}
|
|
|
|
#[test]
|
|
fn test_wait_not_set() {
|
|
let task = Task::new(Uuid::new_v4(), TaskMap::new());
|
|
|
|
assert!(!task.is_waiting());
|
|
assert_eq!(task.get_wait(), None);
|
|
}
|
|
|
|
#[test]
|
|
fn test_wait_in_past() {
|
|
let ts = Utc.ymd(1970, 1, 1).and_hms(0, 0, 0);
|
|
let task = Task::new(
|
|
Uuid::new_v4(),
|
|
vec![(String::from("wait"), format!("{}", ts.timestamp()))]
|
|
.drain(..)
|
|
.collect(),
|
|
);
|
|
dbg!(&task);
|
|
|
|
assert!(!task.is_waiting());
|
|
assert_eq!(task.get_wait(), Some(ts));
|
|
}
|
|
|
|
#[test]
|
|
fn test_wait_in_future() {
|
|
let ts = Utc.ymd(3000, 1, 1).and_hms(0, 0, 0);
|
|
let task = Task::new(
|
|
Uuid::new_v4(),
|
|
vec![(String::from("wait"), format!("{}", ts.timestamp()))]
|
|
.drain(..)
|
|
.collect(),
|
|
);
|
|
|
|
assert!(task.is_waiting());
|
|
assert_eq!(task.get_wait(), Some(ts));
|
|
}
|
|
|
|
#[test]
|
|
fn test_has_tag() {
|
|
let task = Task::new(
|
|
Uuid::new_v4(),
|
|
vec![
|
|
(String::from("tag.abc"), String::from("")),
|
|
(String::from("start.1234"), String::from("")),
|
|
]
|
|
.drain(..)
|
|
.collect(),
|
|
);
|
|
|
|
assert!(task.has_tag(&utag("abc")));
|
|
assert!(!task.has_tag(&utag("def")));
|
|
assert!(task.has_tag(&stag(SyntheticTag::Active)));
|
|
assert!(!task.has_tag(&stag(SyntheticTag::Waiting)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_tags() {
|
|
let task = Task::new(
|
|
Uuid::new_v4(),
|
|
vec![
|
|
(String::from("tag.abc"), String::from("")),
|
|
(String::from("tag.def"), String::from("")),
|
|
// set `wait` so the synthetic tag WAITING is present
|
|
(String::from("wait"), String::from("33158909732")),
|
|
]
|
|
.drain(..)
|
|
.collect(),
|
|
);
|
|
|
|
let mut tags: Vec<_> = task.get_tags().collect();
|
|
tags.sort();
|
|
assert_eq!(
|
|
tags,
|
|
vec![utag("abc"), utag("def"), stag(SyntheticTag::Waiting),]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_tags_invalid_tags() {
|
|
let task = Task::new(
|
|
Uuid::new_v4(),
|
|
vec![
|
|
(String::from("tag.ok"), String::from("")),
|
|
(String::from("tag."), String::from("")),
|
|
(String::from("tag.123"), String::from("")),
|
|
(String::from("tag.a!!"), String::from("")),
|
|
]
|
|
.drain(..)
|
|
.collect(),
|
|
);
|
|
|
|
// only "ok" is OK
|
|
let tags: Vec<_> = task.get_tags().collect();
|
|
assert_eq!(tags, vec![utag("ok")]);
|
|
}
|
|
|
|
fn count_taskmap(task: &TaskMut, f: fn(&(&String, &String)) -> bool) -> usize {
|
|
task.taskmap.iter().filter(f).count()
|
|
}
|
|
|
|
#[test]
|
|
fn test_start() {
|
|
with_mut_task(|mut task| {
|
|
task.start().unwrap();
|
|
assert_eq!(
|
|
count_taskmap(&task, |(k, v)| k.starts_with("start.") && v.is_empty()),
|
|
1
|
|
);
|
|
task.reload().unwrap();
|
|
assert_eq!(
|
|
count_taskmap(&task, |(k, v)| k.starts_with("start.") && v.is_empty()),
|
|
1
|
|
);
|
|
|
|
// second start doesn't change anything..
|
|
task.start().unwrap();
|
|
assert_eq!(
|
|
count_taskmap(&task, |(k, v)| k.starts_with("start.") && v.is_empty()),
|
|
1
|
|
);
|
|
task.reload().unwrap();
|
|
assert_eq!(
|
|
count_taskmap(&task, |(k, v)| k.starts_with("start.") && v.is_empty()),
|
|
1
|
|
);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn test_stop() {
|
|
with_mut_task(|mut task| {
|
|
task.start().unwrap();
|
|
task.stop().unwrap();
|
|
assert_eq!(
|
|
count_taskmap(&task, |(k, v)| k.starts_with("start.") && v.is_empty()),
|
|
0
|
|
);
|
|
assert_eq!(
|
|
count_taskmap(&task, |(k, v)| k.starts_with("start.") && !v.is_empty()),
|
|
1
|
|
);
|
|
task.reload().unwrap();
|
|
assert_eq!(
|
|
count_taskmap(&task, |(k, v)| k.starts_with("start.") && v.is_empty()),
|
|
0
|
|
);
|
|
assert_eq!(
|
|
count_taskmap(&task, |(k, v)| k.starts_with("start.") && !v.is_empty()),
|
|
1
|
|
);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn test_stop_multiple() {
|
|
with_mut_task(|mut task| {
|
|
// simulate a task that has (through the synchronization process) been started twice
|
|
task.task
|
|
.taskmap
|
|
.insert(String::from("start.1234"), String::from(""));
|
|
task.task
|
|
.taskmap
|
|
.insert(String::from("start.5678"), String::from(""));
|
|
|
|
task.stop().unwrap();
|
|
assert_eq!(
|
|
count_taskmap(&task, |(k, v)| k.starts_with("start.") && v.is_empty()),
|
|
0
|
|
);
|
|
assert_eq!(
|
|
count_taskmap(&task, |(k, v)| k.starts_with("start.") && !v.is_empty()),
|
|
2
|
|
);
|
|
task.reload().unwrap();
|
|
assert_eq!(
|
|
count_taskmap(&task, |(k, v)| k.starts_with("start.") && v.is_empty()),
|
|
0
|
|
);
|
|
assert_eq!(
|
|
count_taskmap(&task, |(k, v)| k.starts_with("start.") && !v.is_empty()),
|
|
2
|
|
);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn test_add_tags() {
|
|
with_mut_task(|mut task| {
|
|
task.add_tag(&utag("abc")).unwrap();
|
|
assert!(task.taskmap.contains_key("tag.abc"));
|
|
task.reload().unwrap();
|
|
assert!(task.taskmap.contains_key("tag.abc"));
|
|
// redundant add has no effect..
|
|
task.add_tag(&utag("abc")).unwrap();
|
|
assert!(task.taskmap.contains_key("tag.abc"));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn test_remove_tags() {
|
|
with_mut_task(|mut task| {
|
|
task.add_tag(&utag("abc")).unwrap();
|
|
task.reload().unwrap();
|
|
assert!(task.taskmap.contains_key("tag.abc"));
|
|
|
|
task.remove_tag(&utag("abc")).unwrap();
|
|
assert!(!task.taskmap.contains_key("tag.abc"));
|
|
// redundant remove has no effect..
|
|
task.remove_tag(&utag("abc")).unwrap();
|
|
assert!(!task.taskmap.contains_key("tag.abc"));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn test_priority() {
|
|
assert_eq!(Priority::L.to_taskmap(), "L");
|
|
assert_eq!(Priority::M.to_taskmap(), "M");
|
|
assert_eq!(Priority::H.to_taskmap(), "H");
|
|
assert_eq!(Priority::from_taskmap("L"), Priority::L);
|
|
assert_eq!(Priority::from_taskmap("M"), Priority::M);
|
|
assert_eq!(Priority::from_taskmap("H"), Priority::H);
|
|
}
|
|
|
|
#[test]
|
|
fn test_status() {
|
|
assert_eq!(Status::Pending.to_taskmap(), "P");
|
|
assert_eq!(Status::Completed.to_taskmap(), "C");
|
|
assert_eq!(Status::Deleted.to_taskmap(), "D");
|
|
assert_eq!(Status::from_taskmap("P"), Status::Pending);
|
|
assert_eq!(Status::from_taskmap("C"), Status::Completed);
|
|
assert_eq!(Status::from_taskmap("D"), Status::Deleted);
|
|
}
|
|
}
|