CodeEdit/CodeEditTests/Features/Tasks/TaskManagerTests.swift at 7a591f3e30b2bcf7485e5dc890ea03517bcbe1f7 · thecoolwinter/CodeEdit · GitHub

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
//
//  TaskManagerTests.swift
//  CodeEditTests
//
//  Created by Tommy Ludwig on 08.07.24.
//

import Foundation
import Testing
@testable import CodeEdit

@MainActor
@Suite
class TaskManagerTests {
    var taskManager: TaskManager!
    var mockWorkspaceSettings: CEWorkspaceSettingsData!

    init() throws {
        let workspaceSettings = try JSONDecoder().decode(CEWorkspaceSettingsData.self, from: Data("{}".utf8))
        mockWorkspaceSettings = workspaceSettings
        taskManager = TaskManager(workspaceSettings: mockWorkspaceSettings, workspaceURL: nil)
    }

    func testInitialization() {
        #expect(taskManager != nil)
        #expect(taskManager.availableTasks == mockWorkspaceSettings.tasks)
    }

    @Test
    func executeTaskInZsh() async throws {
        Settings.shared.preferences.terminal.shell = .zsh

        let task = CETask(name: "Test Task", command: "echo 'Hello World'")
        mockWorkspaceSettings.tasks.append(task)
        taskManager.selectedTaskID = task.id
        taskManager.executeActiveTask()

        await waitForExpectation(timeout: .seconds(10)) {
            self.taskManager.activeTasks[task.id]?.status == .finished
        } onTimeout: {
            Issue.record("Status never changed to finished.")
        }

        let outputString = try #require(taskManager.activeTasks[task.id]?.output?.getBufferAsString())
        #expect(outputString.contains("Hello World"))
    }

    @Test
    func executeTaskInBash() async throws {
        Settings.shared.preferences.terminal.shell = .bash

        let task = CETask(name: "Test Task", command: "echo 'Hello World'")
        mockWorkspaceSettings.tasks.append(task)
        taskManager.selectedTaskID = task.id
        taskManager.executeActiveTask()

        await waitForExpectation(timeout: .seconds(10)) {
            self.taskManager.activeTasks[task.id]?.status == .finished
        } onTimeout: {
            Issue.record("Status never changed to finished.")
        }

        let outputString = try #require(taskManager.activeTasks[task.id]?.output?.getBufferAsString())
        #expect(outputString.contains("Hello World"))
    }

    @Test(.disabled("Not sure why but tasks run in shells seem to never receive signals."))
    func terminateSelectedTask() async throws {
        let task = CETask(name: "Test Task", command: "sleep 10")
        mockWorkspaceSettings.tasks.append(task)
        taskManager.selectedTaskID = task.id
        taskManager.executeActiveTask()

        await waitForExpectation {
            taskManager.taskStatus(taskID: task.id) == .running
        } onTimeout: {
            Issue.record("Task did not run")
        }

        taskManager.terminateActiveTask()

        await waitForExpectation(timeout: .seconds(10)) {
            taskManager.taskStatus(taskID: task.id) == .notRunning
        } onTimeout: {
            Issue.record("Task did not terminate. \(taskManager.taskStatus(taskID: task.id))")
        }
    }

    // This test verifies the functionality of suspending and resuming a task.
    // It ensures that suspend signals do not stack up,
    // meaning only one resume signal is required to resume the task,
    // regardless of the number of times `suspendTask()` is called.
    @Test(.disabled("Not sure why but tasks run in shells seem to never receive signals."))
    func suspendAndResumeTask() async throws {
        let task = CETask(name: "Test Task", command: "sleep 5")
        mockWorkspaceSettings.tasks.append(task)
        taskManager.selectedTaskID = task.id
        taskManager.executeActiveTask()

        await waitForExpectation {
            taskManager.taskStatus(taskID: task.id) == .running
        } onTimeout: {
            Issue.record("Task did not start running.")
        }
        taskManager.suspendTask(taskID: task.id)

        await waitForExpectation {
            taskManager.taskStatus(taskID: task.id) == .stopped
        } onTimeout: {
            Issue.record("Task did not suspend")
        }
        taskManager.resumeTask(taskID: task.id)

        await waitForExpectation {
            taskManager.taskStatus(taskID: task.id) == .running
        } onTimeout: {
            Issue.record("Task did not resume")
        }

        taskManager.suspendTask(taskID: task.id)
        taskManager.suspendTask(taskID: task.id)
        taskManager.suspendTask(taskID: task.id)

        await waitForExpectation {
            taskManager.taskStatus(taskID: task.id) == .stopped
        } onTimeout: {
            Issue.record("Task did not suspend after multiple suspend messages.")
        }
        taskManager.resumeTask(taskID: task.id)

        await waitForExpectation {
            taskManager.taskStatus(taskID: task.id) == .running
        } onTimeout: {
            Issue.record("Task did not resume after multiple suspend messages.")
        }
    }
}