feat(tasks): define status graph and progress

src/main/java/com/lab/labtimesheet/tasks/TaskProgress.java

@@ -0,0 +1,40 @@
+package com.lab.labtimesheet.tasks;
+
+import java.util.Collection;
+import java.util.OptionalDouble;
+
+public record TaskProgress(int todo, int inProgress, int blocked, int done) {
+
+    public static TaskProgress from(Collection<TaskStatus> statuses) {
+        int todo = 0;
+        int inProgress = 0;
+        int blocked = 0;
+        int done = 0;
+        for (TaskStatus status : statuses) {
+            switch (status) {
+                case TODO -> todo++;
+                case IN_PROGRESS -> inProgress++;
+                case BLOCKED -> blocked++;
+                case DONE -> done++;
+            }
+        }
+        return new TaskProgress(todo, inProgress, blocked, done);
+    }
+
+    public int total() {
+        return todo + inProgress + blocked + done;
+    }
+
+    public int count(TaskStatus status) {
+        return switch (status) {
+            case TODO -> todo;
+            case IN_PROGRESS -> inProgress;
+            case BLOCKED -> blocked;
+            case DONE -> done;
+        };
+    }
+
+    public OptionalDouble completionPercentage() {
+        return total() == 0 ? OptionalDouble.empty() : OptionalDouble.of(done * 100.0 / total());
+    }
+}

src/main/java/com/lab/labtimesheet/tasks/TaskStatus.java

@@ -0,0 +1,17 @@
+package com.lab.labtimesheet.tasks;
+
+public enum TaskStatus {
+    TODO,
+    IN_PROGRESS,
+    BLOCKED,
+    DONE;
+
+    public boolean canTransitionTo(TaskStatus target) {
+        return switch (this) {
+            case TODO -> target == IN_PROGRESS || target == BLOCKED;
+            case IN_PROGRESS -> target == DONE || target == BLOCKED;
+            case BLOCKED -> target == TODO || target == IN_PROGRESS;
+            case DONE -> target == IN_PROGRESS;
+        };
+    }
+}

src/test/java/com/lab/labtimesheet/tasks/TaskDomainRulesTest.java

@@ -0,0 +1,61 @@
+package com.lab.labtimesheet.tasks;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class TaskDomainRulesTest {
+
+    private static final Map<TaskStatus, Set<TaskStatus>> ALLOWED_TRANSITIONS = Map.of(
+            TaskStatus.TODO, Set.of(TaskStatus.IN_PROGRESS, TaskStatus.BLOCKED),
+            TaskStatus.IN_PROGRESS, Set.of(TaskStatus.DONE, TaskStatus.BLOCKED),
+            TaskStatus.BLOCKED, Set.of(TaskStatus.TODO, TaskStatus.IN_PROGRESS),
+            TaskStatus.DONE, Set.of(TaskStatus.IN_PROGRESS));
+
+    @ParameterizedTest
+    @MethodSource("allStatusTransitions")
+    void acceptsOnlyTheFixedStatusGraph(TaskStatus current, TaskStatus target, boolean expected) {
+        assertThat(current.canTransitionTo(target)).isEqualTo(expected);
+    }
+
+    @Test
+    void reportsNoPercentageForAProjectWithoutTasks() {
+        TaskProgress progress = TaskProgress.from(List.of());
+
+        assertThat(progress.completionPercentage()).isEmpty();
+        assertThat(progress.total()).isZero();
+        assertThat(progress.count(TaskStatus.DONE)).isZero();
+    }
+
+    @Test
+    void countsStatusesAndDonePercentageFromCurrentTasks() {
+        TaskProgress progress = TaskProgress.from(List.of(
+                TaskStatus.TODO,
+                TaskStatus.IN_PROGRESS,
+                TaskStatus.DONE,
+                TaskStatus.DONE));
+
+        assertThat(progress.completionPercentage()).hasValue(50);
+        assertThat(progress.total()).isEqualTo(4);
+        assertThat(progress.count(TaskStatus.TODO)).isEqualTo(1);
+        assertThat(progress.count(TaskStatus.IN_PROGRESS)).isEqualTo(1);
+        assertThat(progress.count(TaskStatus.BLOCKED)).isZero();
+        assertThat(progress.count(TaskStatus.DONE)).isEqualTo(2);
+    }
+
+    private static Stream<Arguments> allStatusTransitions() {
+        return Stream.of(TaskStatus.values())
+                .flatMap(current -> Stream.of(TaskStatus.values())
+                        .map(target -> Arguments.of(
+                                current,
+                                target,
+                                ALLOWED_TRANSITIONS.get(current).contains(target))));
+    }
+}