Skip to main content

sonos_cli/cli/
resolve.rs

1use sonos_sdk::{Group, SonosSystem, Speaker};
2
3use crate::cli::GlobalFlags;
4use crate::config::Config;
5use crate::errors::CliError;
6
7/// Resolve --speaker / --group flags to a Speaker handle.
8///
9/// Priority: --group wins over --speaker. If neither is given, uses config default
10/// or falls back to the first group's coordinator.
11pub fn resolve_speaker(
12    system: &SonosSystem,
13    config: &Config,
14    global: &GlobalFlags,
15) -> Result<Speaker, CliError> {
16    // --group wins over --speaker
17    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    // Default: config group → first group coordinator → first speaker
35    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    // Prefer a group coordinator so we get track/position data
44    // (non-coordinator speakers return NOT_IMPLEMENTED for these)
45    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    // Last resort: first speaker (standalone, no groups)
55    system
56        .speakers()
57        .into_iter()
58        .next()
59        .ok_or_else(|| CliError::SpeakerNotFound("no speakers available".to_string()))
60}
61
62/// Resolve --group / --speaker flags to a Group handle.
63///
64/// Priority: --group wins. If neither flag is given, uses config default
65/// or falls back to the first available group.
66pub 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    // Default: config group → first group
79    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
92/// Resolve --speaker flag for speaker-only commands (bass, treble, loudness).
93/// Rejects --group with a validation error.
94pub 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        // Should pick the first group's coordinator, not an arbitrary speaker
177        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}