harn-hostlib 0.8.103

Opt-in code-intelligence and deterministic-tool host builtins for the Harn VM
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

package com.burinexample

import java.time.Instant
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
import kotlin.test.assertNull
import kotlin.test.assertFailsWith

class TaskWorkflowTest {
    private val service = TaskService()

    @Test
    fun newTaskStartsInTODO() {
        val task = service.create("New task")
        assertEquals(TaskStatus.TODO, task.status)
        assertNull(task.completedAt)
    }

    @Test
    fun validPath_TODO_to_IN_PROGRESS_to_DONE() {
        val task = service.create("Long task")
        assertEquals(TaskStatus.TODO, task.status)

        val inProgress = service.transition(task.id, TaskStatus.IN_PROGRESS)
        assertEquals(TaskStatus.IN_PROGRESS, inProgress.status)
        assertNull(inProgress.completedAt)

        val done = service.transition(task.id, TaskStatus.DONE)
        assertEquals(TaskStatus.DONE, done.status)
        assertNotNull(done.completedAt)
    }

    @Test
    fun validPath_TODO_to_CANCELLED() {
        val task = service.create("Short task")
        assertEquals(TaskStatus.TODO, task.status)

        val cancelled = service.transition(task.id, TaskStatus.CANCELLED)
        assertEquals(TaskStatus.CANCELLED, cancelled.status)
        assertNull(cancelled.completedAt)
    }

    @Test
    fun transition_DONE_to_TODO_throws() {
        val task = service.create("Done task")
        service.transition(task.id, TaskStatus.DONE)

        assertFailsWith<IllegalArgumentException> {
            service.transition(task.id, TaskStatus.TODO)
        }
    }

    @Test
    fun parallel_transitions_FROM_IN_PROGRESS_to_DONE() {
        val task1 = service.create("Task A")
        service.transition(task1.id, TaskStatus.IN_PROGRESS)

        val done = service.transition(task1.id, TaskStatus.DONE)
        assertEquals(TaskStatus.DONE, done.status)
        assertNotNull(done.completedAt)
    }

    @Test
    fun parallel_transitions_FROM_IN_PROGRESS_to_CANCELLED() {
        val task1 = service.create("Task B")
        service.transition(task1.id, TaskStatus.IN_PROGRESS)

        val cancelled = service.transition(task1.id, TaskStatus.CANCELLED)
        assertEquals(TaskStatus.CANCELLED, cancelled.status)
        assertNull(cancelled.completedAt)
    }

    @Test
    fun completedAt_is_set_only_on_DONE() {
        // TODO status: no completedAt
        val todoTask = service.create("Todo task")
        assertNull(todoTask.completedAt)

        // IN_PROGRESS status: no completedAt
        val inProgressTask = service.create("In progress task")
        service.transition(inProgressTask.id, TaskStatus.IN_PROGRESS)
        assertNull(inProgressTask.completedAt)

        // DONE status: completedAt is set
        val doneTask = service.create("Done task")
        service.transition(doneTask.id, TaskStatus.DONE)
        assertNotNull(doneTask.completedAt)

        // CANCELLED status: completedAt is null
        val cancelledTask = service.create("Cancelled task")
        service.transition(cancelledTask.id, TaskStatus.CANCELLED)
        assertNull(cancelledTask.completedAt)
    }

    @Test
    fun transition_DONE_to_CANCELLED_throws() {
        val task = service.create("Done task")
        service.transition(task.id, TaskStatus.DONE)

        assertFailsWith<IllegalArgumentException> {
            service.transition(task.id, TaskStatus.CANCELLED)
        }
    }

    @Test
    fun transition_CANCELLED_to_TODO_throws() {
        val task = service.create("Cancelled task")
        service.transition(task.id, TaskStatus.CANCELLED)

        assertFailsWith<IllegalArgumentException> {
            service.transition(task.id, TaskStatus.TODO)
        }
    }

    @Test
    fun transition_CANCELLED_to_IN_PROGRESS_throws() {
        val task = service.create("Cancelled task")
        service.transition(task.id, TaskStatus.CANCELLED)

        assertFailsWith<IllegalArgumentException> {
            service.transition(task.id, TaskStatus.IN_PROGRESS)
        }
    }

    @Test
    fun completedAt_is_null_before_DONE() {
        val task = service.create("Multi-step task")
        assertNull(task.completedAt)

        service.transition(task.id, TaskStatus.IN_PROGRESS)
        assertNull(task.completedAt)
    }

    @Test
    fun completedAt_is_set_after_DONE() {
        val before = Instant.now()
        val task = service.create("Final task")
        service.transition(task.id, TaskStatus.IN_PROGRESS)
        service.transition(task.id, TaskStatus.DONE)
        val after = Instant.now()

        val completedAt = task.completedAt
        assertNotNull(completedAt)
        assertEquals(true, completedAt.isAfter(before) || completedAt == before)
        assertEquals(true, completedAt.isBefore(after) || completedAt == after)
    }
}