1use sonos_sdk::{Group, SonosSystem, Speaker};
2
3use crate::cli::GlobalFlags;
4use crate::config::Config;
5use crate::errors::CliError;
6
7pub fn resolve_speaker(
12 system: &SonosSystem,
13 config: &Config,
14 global: &GlobalFlags,
15) -> Result<Speaker, CliError> {
16 if let Some(group_name) = &global.group {
18 let resolved = config.resolve_alias(group_name);
19 let g = system
20 .group(resolved)
21 .ok_or_else(|| CliError::GroupNotFound(resolved.to_string()))?;
22 return g
23 .coordinator()
24 .ok_or_else(|| CliError::GroupNotFound(resolved.to_string()));
25 }
26
27 if let Some(speaker_name) = &global.speaker {
28 let resolved = config.resolve_alias(speaker_name);
29 return system
30 .speaker(resolved)
31 .ok_or_else(|| CliError::SpeakerNotFound(resolved.to_string()));
32 }
33
34 if let Some(default_group) = &config.default_group {
36 if let Some(g) = system.group(default_group) {
37 if let Some(coordinator) = g.coordinator() {
38 return Ok(coordinator);
39 }
40 }
41 }
42
43 if let Some(coordinator) = system
46 .groups()
47 .into_iter()
48 .next()
49 .and_then(|g| g.coordinator())
50 {
51 return Ok(coordinator);
52 }
53
54 system
56 .speakers()
57 .into_iter()
58 .next()
59 .ok_or_else(|| CliError::SpeakerNotFound("no speakers available".to_string()))
60}
61
62pub fn resolve_group(
67 system: &SonosSystem,
68 config: &Config,
69 global: &GlobalFlags,
70) -> Result<Group, CliError> {
71 if let Some(group_name) = &global.group {
72 let resolved = config.resolve_alias(group_name);
73 return system
74 .group(resolved)
75 .ok_or_else(|| CliError::GroupNotFound(resolved.to_string()));
76 }
77
78 if let Some(default_group) = &config.default_group {
80 if let Some(g) = system.group(default_group) {
81 return Ok(g);
82 }
83 }
84
85 system
86 .groups()
87 .into_iter()
88 .next()
89 .ok_or_else(|| CliError::GroupNotFound("no groups available".to_string()))
90}
91
92pub fn require_speaker_only(
95 system: &SonosSystem,
96 config: &Config,
97 global: &GlobalFlags,
98 command_name: &str,
99) -> Result<Speaker, CliError> {
100 if global.group.is_some() {
101 return Err(CliError::Validation(format!(
102 "--speaker is required for {command_name}"
103 )));
104 }
105 let name = global
106 .speaker
107 .as_deref()
108 .ok_or_else(|| CliError::Validation(format!("--speaker is required for {command_name}")))?;
109 let resolved = config.resolve_alias(name);
110 system
111 .speaker(resolved)
112 .ok_or_else(|| CliError::SpeakerNotFound(resolved.to_string()))
113}
114
115#[cfg(all(test, feature = "test-helpers"))]
116mod tests {
117 use super::*;
118
119 #[test]
120 fn resolve_speaker_by_name() {
121 let system = SonosSystem::with_speakers(&["Kitchen"]);
122 let config = Config::default();
123 let global = GlobalFlags {
124 speaker: Some("Kitchen".into()),
125 group: None,
126 quiet: false,
127 verbose: 0,
128 no_input: false,
129 };
130 let spk = resolve_speaker(&system, &config, &global).unwrap();
131 assert_eq!(spk.name, "Kitchen");
132 }
133
134 #[test]
135 fn resolve_speaker_not_found() {
136 let system = SonosSystem::with_speakers(&["Kitchen"]);
137 let config = Config::default();
138 let global = GlobalFlags {
139 speaker: Some("Nonexistent".into()),
140 group: None,
141 quiet: false,
142 verbose: 0,
143 no_input: false,
144 };
145 let result = resolve_speaker(&system, &config, &global);
146 assert!(matches!(result, Err(CliError::SpeakerNotFound(_))));
147 }
148
149 #[test]
150 fn resolve_speaker_falls_back_to_first() {
151 let system = SonosSystem::with_speakers(&["Kitchen"]);
152 let config = Config::default();
153 let global = GlobalFlags {
154 speaker: None,
155 group: None,
156 quiet: false,
157 verbose: 0,
158 no_input: false,
159 };
160 let spk = resolve_speaker(&system, &config, &global).unwrap();
161 assert_eq!(spk.name, "Kitchen");
162 }
163
164 #[test]
165 fn resolve_speaker_prefers_group_coordinator() {
166 let system = SonosSystem::with_groups(&["Kitchen", "Bedroom"]);
167 let config = Config::default();
168 let global = GlobalFlags {
169 speaker: None,
170 group: None,
171 quiet: false,
172 verbose: 0,
173 no_input: false,
174 };
175 let spk = resolve_speaker(&system, &config, &global).unwrap();
176 let first_group = system.groups().into_iter().next().unwrap();
178 let expected_coordinator = first_group.coordinator().unwrap();
179 assert_eq!(spk.name, expected_coordinator.name);
180 }
181
182 #[test]
183 fn resolve_speaker_empty_system_fails() {
184 let system = SonosSystem::with_speakers(&[]);
185 let config = Config::default();
186 let global = GlobalFlags {
187 speaker: None,
188 group: None,
189 quiet: false,
190 verbose: 0,
191 no_input: false,
192 };
193 let result = resolve_speaker(&system, &config, &global);
194 assert!(result.is_err());
195 }
196
197 #[test]
198 fn require_speaker_only_rejects_group() {
199 let system = SonosSystem::with_speakers(&["Kitchen"]);
200 let global = GlobalFlags {
201 speaker: None,
202 group: Some("Living Room".into()),
203 quiet: false,
204 verbose: 0,
205 no_input: false,
206 };
207 let result = require_speaker_only(&system, &Config::default(), &global, "bass");
208 assert!(matches!(result, Err(CliError::Validation(_))));
209 }
210
211 #[test]
212 fn require_speaker_only_requires_speaker_flag() {
213 let system = SonosSystem::with_speakers(&["Kitchen"]);
214 let global = GlobalFlags {
215 speaker: None,
216 group: None,
217 quiet: false,
218 verbose: 0,
219 no_input: false,
220 };
221 let result = require_speaker_only(&system, &Config::default(), &global, "bass");
222 assert!(matches!(result, Err(CliError::Validation(_))));
223 }
224
225 #[test]
226 fn require_speaker_only_finds_speaker() {
227 let system = SonosSystem::with_speakers(&["Kitchen"]);
228 let global = GlobalFlags {
229 speaker: Some("Kitchen".into()),
230 group: None,
231 quiet: false,
232 verbose: 0,
233 no_input: false,
234 };
235 let spk = require_speaker_only(&system, &Config::default(), &global, "bass").unwrap();
236 assert_eq!(spk.name, "Kitchen");
237 }
238
239 #[test]
240 fn resolve_group_by_name() {
241 let system = SonosSystem::with_groups(&["Kitchen", "Bedroom"]);
242 let config = Config::default();
243 let global = GlobalFlags {
244 speaker: None,
245 group: Some("Kitchen".into()),
246 quiet: false,
247 verbose: 0,
248 no_input: false,
249 };
250 let grp = resolve_group(&system, &config, &global).unwrap();
251 let coord = grp.coordinator().unwrap();
252 assert_eq!(coord.name, "Kitchen");
253 }
254
255 #[test]
256 fn resolve_group_not_found() {
257 let system = SonosSystem::with_groups(&["Kitchen"]);
258 let config = Config::default();
259 let global = GlobalFlags {
260 speaker: None,
261 group: Some("Nonexistent".into()),
262 quiet: false,
263 verbose: 0,
264 no_input: false,
265 };
266 let result = resolve_group(&system, &config, &global);
267 assert!(matches!(result, Err(CliError::GroupNotFound(_))));
268 }
269
270 #[test]
271 fn resolve_group_falls_back_to_first() {
272 let system = SonosSystem::with_groups(&["Kitchen"]);
273 let config = Config::default();
274 let global = GlobalFlags {
275 speaker: None,
276 group: None,
277 quiet: false,
278 verbose: 0,
279 no_input: false,
280 };
281 let grp = resolve_group(&system, &config, &global).unwrap();
282 let coord = grp.coordinator().unwrap();
283 assert_eq!(coord.name, "Kitchen");
284 }
285
286 #[test]
287 fn resolve_group_uses_config_default() {
288 let system = SonosSystem::with_groups(&["Kitchen", "Bedroom"]);
289 let config = Config {
290 default_group: Some("Bedroom".into()),
291 ..Config::default()
292 };
293 let global = GlobalFlags {
294 speaker: None,
295 group: None,
296 quiet: false,
297 verbose: 0,
298 no_input: false,
299 };
300 let grp = resolve_group(&system, &config, &global).unwrap();
301 let coord = grp.coordinator().unwrap();
302 assert_eq!(coord.name, "Bedroom");
303 }
304
305 #[test]
306 fn resolve_group_empty_system_fails() {
307 let system = SonosSystem::with_groups(&[]);
308 let config = Config::default();
309 let global = GlobalFlags {
310 speaker: None,
311 group: None,
312 quiet: false,
313 verbose: 0,
314 no_input: false,
315 };
316 let result = resolve_group(&system, &config, &global);
317 assert!(matches!(result, Err(CliError::GroupNotFound(_))));
318 }
319
320 #[test]
321 fn resolve_group_flag_wins_over_speaker() {
322 let system = SonosSystem::with_groups(&["Kitchen", "Bedroom"]);
323 let config = Config::default();
324 let global = GlobalFlags {
325 speaker: Some("Bedroom".into()),
326 group: Some("Kitchen".into()),
327 quiet: false,
328 verbose: 0,
329 no_input: false,
330 };
331 let grp = resolve_group(&system, &config, &global).unwrap();
332 let coord = grp.coordinator().unwrap();
333 assert_eq!(coord.name, "Kitchen");
334 }
335
336 #[test]
337 fn resolve_speaker_with_alias() {
338 let system = SonosSystem::with_speakers(&["Master Bedroom"]);
339 let mut config = Config::default();
340 config.set_alias("Master Bedroom", "bed");
341 let global = GlobalFlags {
342 speaker: Some("bed".into()),
343 group: None,
344 quiet: false,
345 verbose: 0,
346 no_input: false,
347 };
348 let spk = resolve_speaker(&system, &config, &global).unwrap();
349 assert_eq!(spk.name, "Master Bedroom");
350 }
351
352 #[test]
353 fn resolve_speaker_alias_not_found_shows_resolved_name() {
354 let system = SonosSystem::with_speakers(&["Kitchen"]);
355 let mut config = Config::default();
356 config.set_alias("Master Bedroom", "bed");
357 let global = GlobalFlags {
358 speaker: Some("bed".into()),
359 group: None,
360 quiet: false,
361 verbose: 0,
362 no_input: false,
363 };
364 let result = resolve_speaker(&system, &config, &global);
365 assert!(matches!(result, Err(CliError::SpeakerNotFound(ref name)) if name == "Master Bedroom"));
366 }
367
368 #[test]
369 fn resolve_group_with_alias() {
370 let system = SonosSystem::with_groups(&["Living Room"]);
371 let mut config = Config::default();
372 config.set_alias("Living Room", "lr");
373 let global = GlobalFlags {
374 speaker: None,
375 group: Some("lr".into()),
376 quiet: false,
377 verbose: 0,
378 no_input: false,
379 };
380 let grp = resolve_group(&system, &config, &global).unwrap();
381 let coord = grp.coordinator().unwrap();
382 assert_eq!(coord.name, "Living Room");
383 }
384
385 #[test]
386 fn require_speaker_only_resolves_alias() {
387 let system = SonosSystem::with_speakers(&["Master Bedroom"]);
388 let mut config = Config::default();
389 config.set_alias("Master Bedroom", "bed");
390 let global = GlobalFlags {
391 speaker: Some("bed".into()),
392 group: None,
393 quiet: false,
394 verbose: 0,
395 no_input: false,
396 };
397 let spk = require_speaker_only(&system, &config, &global, "bass").unwrap();
398 assert_eq!(spk.name, "Master Bedroom");
399 }
400}