planter-core 0.0.7

use std::num::NonZeroU32;

use crate::{
    duration::NonNegativeDuration,
    identifiable::{self, Identifiable},
    money::MultiCurrencyAmount,
    resources::Resource,
};
use anyhow::Context;
use chrono::{DateTime, Utc};
use uuid::Uuid;

#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
/// A task is a unit of work that can be completed by a person or a group of people.
/// It can be assigned resources and can have a start, finish, and duration.
pub struct Task {
    /// The stable identifier of the task.
    id: Uuid,
    /// The name of the task.
    name: String,
    /// The description of the task.
    description: Option<String>,
    /// Whether the task is completed.
    completed: bool,
    /// The start time of the task.
    start: Option<DateTime<Utc>>,
    /// The finish time of the task.
    finish: Option<DateTime<Utc>>,
    /// The duration of the task.
    duration: Option<NonNegativeDuration>,
    /// How many units of each engaged resource this task uses, in the order they were assigned.
    /// A task engages any given resource at most once.
    assignments: Vec<Assignment>,
}

impl Identifiable for Task {
    fn id(&self) -> Uuid {
        self.id
    }
}

/// How many units of one resource a [`Task`] engages.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
struct Assignment {
    resource_id: Uuid,
    quantity: u32,
}

impl Identifiable for Assignment {
    fn id(&self) -> Uuid {
        self.resource_id
    }
}

impl Task {
    /// Creates a new task with the given name.
    ///
    /// # Arguments
    ///
    /// * `name` - The name of the task.
    ///
    /// # Returns
    ///
    /// A new task with the given name.
    ///
    /// # Example
    ///
    /// ```
    /// use planter_core::task::Task;
    ///
    /// let task = Task::new("Become world leader");
    /// assert_eq!(task.name(), "Become world leader");
    /// ```
    #[must_use]
    pub fn new(name: impl Into<String>) -> Self {
        Task {
            id: Uuid::new_v4(),
            name: name.into(),
            description: None,
            completed: false,
            start: None,
            finish: None,
            duration: None,
            assignments: Vec::new(),
        }
    }

    /// Returns the stable identifier of the task.
    ///
    /// # Example
    ///
    /// ```
    /// use planter_core::task::Task;
    ///
    /// let task = Task::new("Become world leader");
    /// let id = task.id();
    /// ```
    #[must_use]
    pub const fn id(&self) -> Uuid {
        self.id
    }

    /// Edits the start time of the task.
    /// If a finish time is already set, the duration is recalculated to `finish - start`.
    /// If the new start time is after the finish time, the finish time is pushed
    /// ahead to match, resulting in a zero duration.
    ///
    /// # Arguments
    ///
    /// * `start` - The new start time of the task.
    ///
    /// # Errors
    ///
    /// Returns an error if the task has a finish date and the start date passed
    /// as parameter is too far from that.
    ///
    /// # Example
    ///
    /// ```
    /// use chrono::Utc;
    /// use planter_core::task::Task;
    ///
    /// let mut task = Task::new("Become world leader");
    /// let start_time = Utc::now();
    /// task.edit_start(start_time).unwrap();
    /// assert_eq!(task.start().unwrap(), start_time);
    /// ```
    pub fn edit_start(&mut self, start: DateTime<Utc>) -> anyhow::Result<()> {
        self.start = Some(start);

        if let Some(finish) = self.finish {
            let finish = if finish < start { start } else { finish };
            self.finish = Some(finish);
            self.duration = Some(
                (finish - start)
                    .try_into()
                    .context("Start and finish times were too far apart")?,
            );
        } else if let Some(duration) = self.duration {
            self.finish = Some(start + *duration);
        }
        Ok(())
    }

    /// Returns the start time of the task. It's None by default.
    ///
    /// # Example
    ///
    /// ```
    /// use chrono::Utc;
    /// use planter_core::task::Task;
    ///
    /// let mut task = Task::new("Become world leader");
    /// assert!(task.start().is_none());
    ///
    /// let start_time = Utc::now();
    /// task.edit_start(start_time).unwrap();
    /// assert_eq!(task.start().unwrap(), start_time);
    /// ```
    #[must_use]
    pub const fn start(&self) -> Option<DateTime<Utc>> {
        self.start
    }

    /// Edits the finish time of the task.
    /// If a start time is already set, the duration is recalculated to `finish - start`.
    /// If the new finish time is before the start time, the start time is pushed
    /// back to match, resulting in a zero duration.
    ///
    /// # Arguments
    ///
    /// * `finish` - The new finish time of the task.
    ///
    /// # Errors
    ///
    /// Returns an error if the task has a start date and the finish date passed
    /// as parameter is too far from that.
    ///
    ///
    /// # Example
    ///
    /// ```
    /// use chrono::Utc;
    /// use planter_core::task::Task;
    ///
    /// let mut task = Task::new("Become world leader");
    /// assert!(task.start().is_none());
    ///
    /// let mut finish_time = Utc::now();
    /// task.edit_finish(finish_time).unwrap();
    /// assert_eq!(task.finish().unwrap(), finish_time);
    /// ```
    pub fn edit_finish(&mut self, finish: DateTime<Utc>) -> anyhow::Result<()> {
        self.finish = Some(finish);

        if let Some(start) = self.start {
            let start = if finish < start {
                self.start = Some(finish);
                finish
            } else {
                start
            };
            let duration = finish - start;
            self.duration = Some(
                duration
                    .try_into()
                    .context("Start time and finish time were too far apart")?,
            );
        } else if let Some(duration) = self.duration {
            self.start = Some(finish - *duration);
        }
        Ok(())
    }

    /// Returns the finish time of the task. It's None by default.
    ///
    /// # Example
    ///
    /// ```
    /// use chrono::Utc;
    /// use planter_core::task::Task;
    ///
    /// let mut task = Task::new("Become world leader");
    /// assert!(task.finish().is_none());
    /// let finish_time = Utc::now();
    /// task.edit_finish(finish_time).unwrap();
    /// assert_eq!(task.finish().unwrap(), finish_time);
    /// ```
    #[must_use]
    pub const fn finish(&self) -> Option<DateTime<Utc>> {
        self.finish
    }

    /// Edits the duration of the task. If the task has a start time, finish time will be updated accordingly.
    ///
    /// # Arguments
    ///
    /// * `duration` - The new duration of the task.
    ///
    /// # Example
    ///
    /// ```
    /// use chrono::{Utc, Duration};
    /// use planter_core::{task::Task, duration::NonNegativeDuration};
    ///
    /// let mut task = Task::new("Become world leader");
    /// task.edit_duration(Duration::minutes(30).try_into().unwrap());
    /// assert!(task.duration().is_some());
    /// assert_eq!(task.duration().unwrap(), Duration::minutes(30).try_into().unwrap());
    /// ```
    pub fn edit_duration(&mut self, duration: NonNegativeDuration) {
        self.duration = Some(duration);

        if let Some(start) = self.start() {
            let finish = start + *duration;
            self.finish = Some(finish);
        } else if let Some(finish) = self.finish() {
            self.start = Some(finish - *duration);
        }
    }

    /// Records that the task engages `quantity` units of `resource_id`, replacing any existing
    /// entry for that resource (a task engages any given resource at most once). To remove an
    /// assignment, use [`Self::unassign`] instead.
    ///
    /// Internal: a `Task` has no view of the project's resource pool, so this can't check that
    /// `resource_id` refers to a real resource. Callers go through
    /// [`crate::project::Project::assign_resource`], which does.
    pub(crate) fn assign(&mut self, resource_id: Uuid, quantity: NonZeroU32) {
        identifiable::upsert(
            &mut self.assignments,
            Assignment {
                resource_id,
                quantity: quantity.get(),
            },
        );
    }

    /// Iterates the task's resource assignments as `(resource_id, quantity)` pairs, in the
    /// order they were assigned: how many units of each engaged resource the task uses.
    /// Populate them with [`crate::project::Project::assign_resource`].
    ///
    /// # Example
    ///
    /// ```
    /// use planter_core::task::Task;
    ///
    /// assert_eq!(Task::new("Become world leader").assignments().count(), 0);
    /// ```
    pub fn assignments(&self) -> impl Iterator<Item = (Uuid, u32)> + '_ {
        self.assignments.iter().map(|a| (a.resource_id, a.quantity))
    }

    /// Returns how many units of `resource_id` this task engages, or `None` if it doesn't engage
    /// it at all.
    ///
    /// # Example
    ///
    /// ```
    /// use planter_core::task::Task;
    /// use uuid::Uuid;
    ///
    /// assert_eq!(Task::new("Become world leader").assignment(Uuid::new_v4()), None);
    /// ```
    #[must_use]
    pub fn assignment(&self, resource_id: Uuid) -> Option<u32> {
        identifiable::find(&self.assignments, resource_id).map(|a| a.quantity)
    }

    /// Computes the task's cost: the sum, grouped by currency, of each assignment's
    /// [`Resource::usage_cost`](crate::resources::Resource::usage_cost) for the task's duration.
    /// `resources` is the project's resource pool, used to resolve each assignment.
    ///
    /// Each assignment contributes `hourly_rate * hours * quantity`, where `hours` is the task's
    /// duration in whole hours (`0` if unset). A resource with no rate, or a `resource_id` not
    /// in `resources`, contributes nothing. One-time purchase costs are not counted here; they
    /// belong to the resource (see
    /// [`Resource::purchase_cost`](crate::resources::Resource::purchase_cost)).
    ///
    /// Each amount is priced in its resource's own currency; different currencies stay as
    /// separate entries in the returned [`MultiCurrencyAmount`], never blended. Arithmetic
    /// saturates instead of overflowing.
    ///
    /// Internal: needs the project's resource pool. The public entry point is
    /// [`crate::project::Project::task_cost`].
    #[must_use]
    pub(crate) fn cost(&self, resources: &[Resource]) -> MultiCurrencyAmount {
        let hours = self.duration_hours();

        self.assignments
            .iter()
            .filter_map(|a| {
                let resource = identifiable::find(resources, a.resource_id)?;
                resource.usage_cost(hours, a.quantity)
            })
            .sum()
    }

    /// Removes the task's assignment for `resource_id`, returning the quantity it engaged, or
    /// `None` if the task didn't engage that resource. Also used when the resource is removed
    /// from the project, so tasks never keep an assignment pointing at nothing.
    ///
    /// Internal: the public entry point is [`crate::project::Project::unassign_resource`].
    pub(crate) fn unassign(&mut self, resource_id: Uuid) -> Option<u32> {
        identifiable::remove_by_id(&mut self.assignments, resource_id).map(|a| a.quantity)
    }

    /// Edits the name of the task.
    ///
    /// # Arguments
    ///
    /// * `name` - The new name of the task.
    ///
    /// # Example
    ///
    /// ```
    /// use planter_core::task::Task;
    ///
    /// let mut task = Task::new("Become world leader");
    /// task.edit_name("Become world boss");
    /// assert_eq!(task.name(), "Become world boss");
    /// ```
    pub fn edit_name(&mut self, name: impl Into<String>) {
        self.name = name.into();
    }

    /// Returns the name of the task.
    ///
    /// # Example
    ///
    /// ```
    /// use planter_core::task::Task;
    ///
    /// let mut task = Task::new("Become world leader");
    /// assert_eq!(task.name(), "Become world leader");
    /// ```
    #[must_use]
    pub fn name(&self) -> &str {
        &self.name
    }

    /// Edits the description of the task.
    ///
    /// # Arguments
    ///
    /// * `description` - The new description of the task.
    ///
    /// # Example
    ///
    /// ```
    /// use planter_core::task::Task;
    ///
    /// let mut task = Task::new("Become world leader");
    /// task.edit_description("Description");
    /// assert_eq!(task.description(), Some("Description"));
    /// ```
    pub fn edit_description(&mut self, description: impl Into<String>) {
        self.description = Some(description.into());
    }

    /// Clears the description of the task, setting it to `None`.
    ///
    /// # Example
    ///
    /// ```
    /// use planter_core::task::Task;
    ///
    /// let mut task = Task::new("Become world leader");
    /// task.edit_description("Description");
    /// assert_eq!(task.description(), Some("Description"));
    ///
    /// task.clear_description();
    /// assert!(task.description().is_none());
    /// ```
    pub fn clear_description(&mut self) {
        self.description = None;
    }

    /// Returns the description of the task.
    ///
    /// # Example
    ///
    /// ```
    /// use planter_core::task::Task;
    ///
    /// let mut task = Task::new("Become world leader");
    /// task.edit_description("Description");
    /// assert_eq!(task.description(), Some("Description"));
    /// ```
    #[must_use]
    pub fn description(&self) -> Option<&str> {
        self.description.as_deref()
    }

    /// Whether the task is completed. It's false by default.
    ///
    /// # Example
    ///
    /// ```
    /// use planter_core::task::Task;
    ///
    /// let mut task = Task::new("Become world leader");
    /// assert!(!task.completed());
    /// task.toggle_completed();
    /// assert!(task.completed());
    /// ```
    #[must_use]
    pub const fn completed(&self) -> bool {
        self.completed
    }

    /// Marks the task as completed.
    ///
    /// # Example
    ///
    /// ```
    /// use planter_core::task::Task;
    ///
    /// let mut task = Task::new("Become world leader");
    /// assert!(!task.completed());
    /// task.toggle_completed();
    /// assert!(task.completed());
    /// task.toggle_completed();
    /// assert!(!task.completed());
    /// ```
    pub const fn toggle_completed(&mut self) {
        self.completed = !self.completed;
    }

    /// Returns the duration of the task. It's None by default.
    ///
    /// # Example
    ///
    /// ```
    /// use chrono::{Utc, Duration};
    /// use planter_core::task::Task;
    ///
    /// let mut task = Task::new("Become world leader");
    /// assert!(task.duration().is_none());
    ///
    /// task.edit_duration(Duration::hours(1).try_into().unwrap());
    /// assert!(task.duration().unwrap() == Duration::hours(1).try_into().unwrap());
    /// ```
    #[must_use]
    pub const fn duration(&self) -> Option<NonNegativeDuration> {
        self.duration
    }

    /// Returns the task's duration in whole hours, `0` if unset. This is the figure cost
    /// calculations multiply resource rates by; a partial hour is truncated, saturating at
    /// [`u64::MAX`].
    ///
    /// # Example
    ///
    /// ```
    /// use chrono::Duration;
    /// use planter_core::task::Task;
    ///
    /// let mut task = Task::new("Become world leader");
    /// assert_eq!(task.duration_hours(), 0);
    /// task.edit_duration(Duration::minutes(150).try_into().unwrap());
    /// assert_eq!(task.duration_hours(), 2);
    /// ```
    #[must_use]
    pub fn duration_hours(&self) -> u64 {
        self.duration
            .map_or(0, |d| u64::try_from(d.num_hours()).unwrap_or(u64::MAX))
    }
}

#[cfg(test)]
/// Utilities to test Tasks.
pub mod test_utils {
    use proptest::prelude::*;

    use super::Task;

    /// Generates an empty task with a random name.
    pub fn task_strategy() -> impl Strategy<Value = Task> {
        ".*".prop_map(Task::new)
    }
}

#[cfg(test)]
mod tests {
    use chrono::Duration;
    use proptest::prelude::*;

    use crate::money::{Currency, Money};
    use crate::resources::Resource;
    use crate::task::test_utils::task_strategy;

    use super::*;

    const MAX_TEST_MS: i64 = 1_000_000;

    /// Builds the resource pool `Task::cost` expects.
    fn pool(resources: impl IntoIterator<Item = Resource>) -> Vec<Resource> {
        resources.into_iter().collect()
    }

    /// Shorthand for a non-zero assignment quantity in tests.
    fn nz(n: u32) -> NonZeroU32 {
        NonZeroU32::new(n).unwrap()
    }

    proptest! {
        #[test]
        fn duration_is_properly_set_when_adding_start_and_finish_time(milliseconds in 0..MAX_TEST_MS) {
            let start = Utc::now();
            let finish = start + Duration::milliseconds(milliseconds);
            let mut task = Task::new("World domination");

            task.edit_start(start).unwrap();
            task.edit_finish(finish).unwrap();

            assert!(task.duration().unwrap() == Duration::milliseconds(milliseconds).try_into().unwrap());
        }

        #[test]
        fn task_times_stay_none_when_adding_duration(milliseconds in 0..MAX_TEST_MS) {
            let mut task = Task::new("World domination");

            let duration = Duration::milliseconds(milliseconds).try_into().unwrap();
            task.edit_duration(duration);
            assert!(task.finish().is_none());
            assert!(task.start().is_none());
        }

        #[test]
        fn finish_time_is_properly_set_when_adding_duration(milliseconds in 0..MAX_TEST_MS) {
            let start = Utc::now();
            let mut task = Task::new("World domination");

            task.edit_start(start).unwrap();
            let duration = Duration::milliseconds(milliseconds).try_into().unwrap();
            task.edit_duration(duration);
            assert!(task.finish().unwrap() == start + *duration);
        }

        #[test]
        fn finish_time_is_properly_pushed_ahead_when_adding_duration(milliseconds in 0..MAX_TEST_MS) {
            let start = Utc::now();
            let finish = start + Duration::milliseconds(milliseconds);
            let mut task = Task::new("World domination");

            task.edit_start(start).unwrap();
            task.edit_finish(finish).unwrap();

            let duration = Duration::milliseconds(milliseconds + 1).try_into().unwrap();
            task.edit_duration(duration);
            assert!(task.finish().unwrap() == start + *duration);
        }


        #[test]
        fn start_time_is_properly_pushed_back_when_adding_earlier_finish_time(milliseconds in 0..MAX_TEST_MS) {
            let start = Utc::now();
            let finish = start - Duration::milliseconds(milliseconds);
            let mut task = Task::new("World domination");

            task.edit_start(start).unwrap();
            task.edit_finish(finish).unwrap();

            assert!(task.start().unwrap() == task.finish().unwrap());
        }
    }

    #[test]
    fn edit_start_clamps_finish_when_start_after_finish() {
        let finish = Utc::now();
        let start = finish + Duration::milliseconds(1);
        let mut task = Task::new("World domination");

        task.edit_finish(finish).unwrap();
        task.edit_start(start).unwrap();

        assert_eq!(task.finish(), Some(start));
        assert_eq!(
            task.duration(),
            Some(Duration::milliseconds(0).try_into().unwrap())
        );
    }

    proptest! {
        #[test]
        fn toggle_completed_is_self_inverse(mut task in task_strategy()) {
            let original = task.completed();
            task.toggle_completed();
            assert_eq!(task.completed(), !original);
            task.toggle_completed();
            assert_eq!(task.completed(), original);
        }

        #[test]
        fn assign_increments_count(mut task in task_strategy()) {
            let count = task.assignments().count();
            task.assign(Uuid::new_v4(), nz(1));
            assert_eq!(task.assignments().count(), count + 1);
        }

        #[test]
        fn edit_name_roundtrip(mut task in task_strategy(), name in ".*") {
            task.edit_name(&name);
            assert_eq!(task.name(), &name);
        }

        #[test]
        fn start_without_finish_or_duration(start_millis in 0..MAX_TEST_MS) {
            let start = Utc::now() + chrono::Duration::milliseconds(start_millis);
            let mut task = Task::new("test");
            task.edit_start(start).unwrap();
            assert!(task.finish().is_none());
            assert!(task.duration().is_none());
        }

        #[test]
        fn edit_start_and_duration_sets_finish(milliseconds in 0..MAX_TEST_MS) {
            let start = Utc::now();
            let mut task = Task::new("test");
            task.edit_start(start).unwrap();
            let duration = chrono::Duration::milliseconds(milliseconds).try_into().unwrap();
            task.edit_duration(duration);
            assert_eq!(task.finish(), Some(start + *duration));
        }

        #[test]
        fn clear_description_sets_to_none(mut task in task_strategy(), desc in ".*") {
            task.edit_description(&desc);
            assert_eq!(task.description(), Some(desc.as_str()));
            task.clear_description();
            assert!(task.description().is_none());
        }

        #[test]
        fn unassign_works_correctly(mut task in task_strategy()) {
            let a = Uuid::new_v4();
            let b = Uuid::new_v4();
            assert!(task.unassign(a).is_none());
            task.assign(a, nz(1));
            task.assign(b, nz(1));
            assert_eq!(task.assignments().count(), 2);
            assert_eq!(task.unassign(a), Some(1));
            assert_eq!(task.assignments().count(), 1);
            assert!(task.unassign(a).is_none());
        }

        #[test]
        fn assigning_the_same_resource_twice_replaces_it(mut task in task_strategy()) {
            let id = Uuid::new_v4();
            let before = task.assignments().count();
            task.assign(id, nz(2));
            task.assign(id, nz(1));
            assert_eq!(task.assignments().count(), before + 1);
            assert_eq!(task.assignments().find(|(r, _)| *r == id), Some((id, 1)));
        }

        #[test]
        fn edit_start_with_duration_infers_finish(milliseconds in 0..MAX_TEST_MS) {
            let start = Utc::now();
            let duration = chrono::Duration::milliseconds(milliseconds).try_into().unwrap();
            let mut task = Task::new("World domination");
            task.edit_duration(duration);
            task.edit_start(start).unwrap();
            assert_eq!(task.finish(), Some(start + *duration));
        }

        #[test]
        fn edit_finish_with_duration_infers_start(milliseconds in 0..MAX_TEST_MS) {
            let finish = Utc::now();
            let duration = chrono::Duration::milliseconds(milliseconds).try_into().unwrap();
            let mut task = Task::new("World domination");
            task.edit_duration(duration);
            task.edit_finish(finish).unwrap();
            assert_eq!(task.start(), Some(finish - *duration));
        }

        #[test]
        fn edit_duration_with_finish_infers_start(milliseconds in 0..MAX_TEST_MS) {
            let finish = Utc::now();
            let duration = chrono::Duration::milliseconds(milliseconds).try_into().unwrap();
            let mut task = Task::new("World domination");
            task.edit_finish(finish).unwrap();
            task.edit_duration(duration);
            assert_eq!(task.start(), Some(finish - *duration));
        }

        #[test]
        fn cost_rate_only(rate in 0u64..1000, hours in 0i64..1000) {
            let mut task = Task::new("test");
            task.edit_duration(Duration::hours(hours).try_into().unwrap());

            let resource = Resource::new("Intern".parse().unwrap()).at_hourly_rate(Money::from_minor_units(rate, Currency::EUR));
            task.assign(resource.id(), nz(1));

            let expected = Money::from_minor_units(rate * u64::try_from(hours).unwrap(), Currency::EUR);
            assert_eq!(task.cost(&pool([resource])), expected.into());
        }

        #[test]
        fn cost_scales_with_assignment_quantity(quantity in 1u32..1000, rate in 0u64..1000) {
            let mut task = Task::new("test");
            task.edit_duration(Duration::hours(1).try_into().unwrap());

            let resource = Resource::new("Crowbar".parse().unwrap()).at_hourly_rate(Money::from_minor_units(rate, Currency::EUR));
            task.assign(resource.id(), nz(quantity));

            let expected = Money::from_minor_units(u64::from(quantity) * rate, Currency::EUR);
            assert_eq!(task.cost(&pool([resource])), expected.into());
        }

        #[test]
        fn cost_sums_every_assignment(rate in 0u64..500, hours in 0i64..500) {
            let mut task = Task::new("test");
            task.edit_duration(Duration::hours(hours).try_into().unwrap());

            let intern = Resource::new("Intern".parse().unwrap()).at_hourly_rate(Money::from_minor_units(rate, Currency::EUR));
            task.assign(intern.id(), nz(1));

            let server = Resource::new("Server".parse().unwrap()).at_hourly_rate(Money::from_minor_units(rate, Currency::EUR));
            task.assign(server.id(), nz(1));

            let hours_u64 = u64::try_from(hours).unwrap();
            // Both resources are in EUR, so it's one entry.
            let expected = Money::from_minor_units(2 * rate * hours_u64, Currency::EUR);
            assert_eq!(task.cost(&pool([intern, server])), expected.into());
        }
    }

    #[test]
    fn assignments_are_iterated_in_insertion_order() {
        let mut task = Task::new("test");
        let a = Uuid::new_v4();
        let b = Uuid::new_v4();
        let c = Uuid::new_v4();
        task.assign(a, nz(1));
        task.assign(b, nz(1));
        task.assign(c, nz(1));

        let ids: Vec<_> = task.assignments().map(|(id, _)| id).collect();
        assert_eq!(ids, vec![a, b, c]);
    }

    #[test]
    fn cost_is_zero_with_no_assignments() {
        let mut task = Task::new("test");
        task.edit_duration(Duration::hours(10).try_into().unwrap());
        assert!(task.cost(&pool([])).is_empty());
    }

    #[test]
    fn cost_is_zero_when_the_resource_has_no_rate() {
        let mut task = Task::new("test");
        task.edit_duration(Duration::hours(10).try_into().unwrap());
        let resource = Resource::new("Stimpack".parse().unwrap());
        task.assign(resource.id(), nz(1));
        assert!(task.cost(&pool([resource])).is_empty());
    }

    #[test]
    fn cost_is_zero_when_duration_is_unset() {
        let mut task = Task::new("test");
        let resource = Resource::new("Intern".parse().unwrap())
            .at_hourly_rate(Money::from_minor_units(50, Currency::EUR));
        task.assign(resource.id(), nz(1));
        assert!(task.cost(&pool([resource])).is_empty());
    }

    #[test]
    fn cost_ignores_an_assignment_not_in_the_pool() {
        let mut task = Task::new("test");
        task.edit_duration(Duration::hours(10).try_into().unwrap());
        task.assign(Uuid::new_v4(), nz(1));
        assert!(task.cost(&pool([])).is_empty());
    }

    #[test]
    fn cost_does_not_count_purchases() {
        use crate::resources::Purchase;

        let mut task = Task::new("test");
        task.edit_duration(Duration::hours(10).try_into().unwrap());
        let mut resource = Resource::new("Stimpack".parse().unwrap());
        resource.add_purchase(
            Purchase::builder()
                .quantity(40)
                .unit_price(Money::from_minor_units(500, Currency::EUR))
                .build(),
        );
        task.assign(resource.id(), nz(40));
        assert!(task.cost(&pool([resource])).is_empty());
    }

    #[test]
    fn cost_does_not_saturate_for_a_realistic_multi_year_task() {
        // An ~8-year task (70,000 hours) at a high hourly rate: realistic for a
        // long-running project, not a pathological input.
        let mut task = Task::new("test");
        task.edit_duration(Duration::hours(70_000).try_into().unwrap());
        let resource = Resource::new("Intern".parse().unwrap())
            .at_hourly_rate(Money::from_minor_units(u64::from(u16::MAX), Currency::EUR));
        task.assign(resource.id(), nz(1));

        assert_eq!(
            task.cost(&pool([resource])).in_currency(Currency::EUR),
            Some(Money::from_minor_units(
                u64::from(u16::MAX) * 70_000,
                Currency::EUR
            )),
        );
    }

    #[test]
    fn cost_keeps_different_currencies_as_separate_entries() {
        let mut task = Task::new("test");
        task.edit_duration(Duration::hours(10).try_into().unwrap());

        let intern = Resource::new("Intern".parse().unwrap())
            .at_hourly_rate(Money::from_minor_units(10, Currency::EUR));
        task.assign(intern.id(), nz(1));

        let server = Resource::new("Server".parse().unwrap())
            .at_hourly_rate(Money::from_minor_units(50, Currency::USD));
        task.assign(server.id(), nz(1));

        let cost = task.cost(&pool([intern, server]));
        let entries: Vec<_> = cost.iter().collect();
        assert_eq!(entries.len(), 2);
        assert!(entries.contains(&Money::from_minor_units(100, Currency::EUR)));
        assert!(entries.contains(&Money::from_minor_units(500, Currency::USD)));
    }
}

#[cfg(all(test, feature = "serde"))]
mod serde_tests {
    use proptest::prelude::*;

    use crate::task::Task;
    use crate::task::test_utils::task_strategy;

    proptest! {
        #[test]
        fn serde_roundtrip(task in task_strategy()) {
            let json = serde_json::to_string(&task).unwrap();
            let deserialized: Task = serde_json::from_str(&json).unwrap();
            let json2 = serde_json::to_string(&deserialized).unwrap();
            let v1: serde_json::Value = serde_json::from_str(&json).unwrap();
            let v2: serde_json::Value = serde_json::from_str(&json2).unwrap();
            assert_eq!(v1, v2, "serde roundtrip must produce equivalent JSON");
        }
    }
}