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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
|
"""Tests for output formatting utilities."""
from __future__ import annotations
import io
import json
import sys
import pytest
from tmuxp.cli._output import OutputFormatter, OutputMode, get_output_mode
def test_output_mode_values() -> None:
"""Verify OutputMode enum values."""
assert OutputMode.HUMAN.value == "human"
assert OutputMode.JSON.value == "json"
assert OutputMode.NDJSON.value == "ndjson"
def test_output_mode_members() -> None:
"""Verify all expected members exist."""
members = list(OutputMode)
assert len(members) == 3
assert OutputMode.HUMAN in members
assert OutputMode.JSON in members
assert OutputMode.NDJSON in members
def test_get_output_mode_default_is_human() -> None:
"""Default mode should be HUMAN when no flags."""
assert get_output_mode(json_flag=False, ndjson_flag=False) == OutputMode.HUMAN
def test_get_output_mode_json_flag() -> None:
"""JSON flag should return JSON mode."""
assert get_output_mode(json_flag=True, ndjson_flag=False) == OutputMode.JSON
def test_get_output_mode_ndjson_flag() -> None:
"""NDJSON flag should return NDJSON mode."""
assert get_output_mode(json_flag=False, ndjson_flag=True) == OutputMode.NDJSON
def test_get_output_mode_ndjson_takes_precedence() -> None:
"""NDJSON should take precedence when both flags set."""
assert get_output_mode(json_flag=True, ndjson_flag=True) == OutputMode.NDJSON
def test_output_formatter_default_mode_is_human() -> None:
"""Default mode should be HUMAN."""
formatter = OutputFormatter()
assert formatter.mode == OutputMode.HUMAN
def test_output_formatter_explicit_mode() -> None:
"""Mode can be set explicitly."""
formatter = OutputFormatter(OutputMode.JSON)
assert formatter.mode == OutputMode.JSON
def test_output_formatter_json_buffer_initially_empty() -> None:
"""JSON buffer should start empty."""
formatter = OutputFormatter(OutputMode.JSON)
assert formatter._json_buffer == []
def test_emit_json_buffers_data() -> None:
"""JSON mode should buffer data."""
formatter = OutputFormatter(OutputMode.JSON)
formatter.emit({"name": "test1"})
formatter.emit({"name": "test2"})
assert len(formatter._json_buffer) == 2
assert formatter._json_buffer[0] == {"name": "test1"}
assert formatter._json_buffer[1] == {"name": "test2"}
def test_emit_human_does_nothing() -> None:
"""HUMAN mode emit should not buffer or output."""
formatter = OutputFormatter(OutputMode.HUMAN)
formatter.emit({"name": "test"})
assert formatter._json_buffer == []
def test_emit_ndjson_writes_immediately(capsys: pytest.CaptureFixture[str]) -> None:
"""NDJSON mode should write one JSON object per line immediately."""
formatter = OutputFormatter(OutputMode.NDJSON)
formatter.emit({"name": "test1", "value": 42})
formatter.emit({"name": "test2", "value": 43})
captured = capsys.readouterr()
lines = captured.out.strip().split("\n")
assert len(lines) == 2
assert json.loads(lines[0]) == {"name": "test1", "value": 42}
assert json.loads(lines[1]) == {"name": "test2", "value": 43}
def test_emit_text_human_outputs(capsys: pytest.CaptureFixture[str]) -> None:
"""HUMAN mode should output text."""
formatter = OutputFormatter(OutputMode.HUMAN)
formatter.emit_text("Hello, world!")
captured = capsys.readouterr()
assert captured.out == "Hello, world!\n"
def test_emit_text_json_silent(capsys: pytest.CaptureFixture[str]) -> None:
"""JSON mode should not output text."""
formatter = OutputFormatter(OutputMode.JSON)
formatter.emit_text("Hello, world!")
captured = capsys.readouterr()
assert captured.out == ""
def test_emit_text_ndjson_silent(capsys: pytest.CaptureFixture[str]) -> None:
"""NDJSON mode should not output text."""
formatter = OutputFormatter(OutputMode.NDJSON)
formatter.emit_text("Hello, world!")
captured = capsys.readouterr()
assert captured.out == ""
def test_finalize_json_outputs_array(capsys: pytest.CaptureFixture[str]) -> None:
"""JSON mode finalize should output formatted array."""
formatter = OutputFormatter(OutputMode.JSON)
formatter.emit({"name": "test1"})
formatter.emit({"name": "test2"})
formatter.finalize()
captured = capsys.readouterr()
data = json.loads(captured.out)
assert isinstance(data, list)
assert len(data) == 2
assert data[0] == {"name": "test1"}
assert data[1] == {"name": "test2"}
def test_finalize_json_clears_buffer() -> None:
"""JSON mode finalize should clear the buffer."""
formatter = OutputFormatter(OutputMode.JSON)
formatter.emit({"name": "test"})
assert len(formatter._json_buffer) == 1
# Capture output to prevent test pollution
old_stdout = sys.stdout
sys.stdout = io.StringIO()
try:
formatter.finalize()
finally:
sys.stdout = old_stdout
assert formatter._json_buffer == []
def test_finalize_json_empty_buffer_no_output(
capsys: pytest.CaptureFixture[str],
) -> None:
"""JSON mode finalize with empty buffer should not output."""
formatter = OutputFormatter(OutputMode.JSON)
formatter.finalize()
captured = capsys.readouterr()
assert captured.out == ""
def test_finalize_human_no_op(capsys: pytest.CaptureFixture[str]) -> None:
"""HUMAN mode finalize should do nothing."""
formatter = OutputFormatter(OutputMode.HUMAN)
formatter.finalize()
captured = capsys.readouterr()
assert captured.out == ""
def test_finalize_ndjson_no_op(capsys: pytest.CaptureFixture[str]) -> None:
"""NDJSON mode finalize should do nothing (already streamed)."""
formatter = OutputFormatter(OutputMode.NDJSON)
formatter.finalize()
captured = capsys.readouterr()
assert captured.out == ""
def test_json_workflow(capsys: pytest.CaptureFixture[str]) -> None:
"""Test complete JSON output workflow."""
formatter = OutputFormatter(OutputMode.JSON)
# Emit several records
formatter.emit({"name": "workspace1", "path": "/path/1"})
formatter.emit({"name": "workspace2", "path": "/path/2"})
# Nothing output yet
captured = capsys.readouterr()
assert captured.out == ""
# Finalize outputs everything
formatter.finalize()
captured = capsys.readouterr()
data = json.loads(captured.out)
assert len(data) == 2
def test_ndjson_workflow(capsys: pytest.CaptureFixture[str]) -> None:
"""Test complete NDJSON output workflow."""
formatter = OutputFormatter(OutputMode.NDJSON)
# Each emit outputs immediately
formatter.emit({"name": "workspace1"})
captured = capsys.readouterr()
assert json.loads(captured.out.strip()) == {"name": "workspace1"}
formatter.emit({"name": "workspace2"})
captured = capsys.readouterr()
assert json.loads(captured.out.strip()) == {"name": "workspace2"}
# Finalize is no-op
formatter.finalize()
captured = capsys.readouterr()
assert captured.out == ""
def test_human_workflow(capsys: pytest.CaptureFixture[str]) -> None:
"""Test complete HUMAN output workflow."""
formatter = OutputFormatter(OutputMode.HUMAN)
# emit does nothing in human mode
formatter.emit({"name": "ignored"})
# emit_text outputs text
formatter.emit_text("Workspace: test")
formatter.emit_text(" Path: /path/to/test")
captured = capsys.readouterr()
assert "Workspace: test" in captured.out
assert "Path: /path/to/test" in captured.out
# Finalize is no-op
formatter.finalize()
captured = capsys.readouterr()
assert captured.out == ""
|
