fader_master/config/tests/editor.rs

525 lines
17 KiB
Rust

use fader_config::{
Action, MessageKind, MixerLayoutEntry, ProfileDocument, SelectorDraft, SelectorField,
SelectorPattern, TargetKind,
};
const PROFILE: &str = include_str!("../../examples/profiles/desktop.toml");
#[test]
fn unnamed_separators_can_be_created_renamed_and_reloaded() {
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
draft.add_separator("spacer", "", 0).unwrap();
draft.add_separator("divider", "Divider", 1).unwrap();
draft.set_separator_label("divider", "").unwrap();
let reloaded = ProfileDocument::parse(&draft.finish().unwrap()).unwrap();
let profile = reloaded.preview().unwrap();
for entry in &profile.mixer_layout()[..2] {
assert!(matches!(entry, MixerLayoutEntry::Separator { label, .. } if label.is_empty()));
}
}
#[test]
fn separator_presentation_round_trips_without_changing_order() {
use fader_config::{SeparatorDecoration, SeparatorSize};
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
draft.add_separator("heading", "Heading", 0).unwrap();
draft
.set_separator_presentation("heading", SeparatorSize::Fill, SeparatorDecoration::Double)
.unwrap();
let draft = ProfileDocument::parse(&draft.finish().unwrap()).unwrap();
assert!(matches!(
&draft.preview().unwrap().mixer_layout()[0],
MixerLayoutEntry::Separator {
size: SeparatorSize::Fill,
decoration: SeparatorDecoration::Double,
..
}
));
assert!(
fader_config::Profile::parse(&draft.source().replace("size = \"fill\"", "size = \"huge\""))
.is_err()
);
}
#[test]
fn draft_adds_a_discovered_midi_surface_with_durable_identity() {
let mut draft = ProfileDocument::empty("default").unwrap();
draft
.add_surface(
"apc-mini",
"APC MINI",
"APC MINI:APC MINI MIDI 1",
Some("APC MINI:APC MINI MIDI 1"),
Some("09e8"),
Some("0028"),
Some("Ver00.10"),
Some("pci-0000:00:14.0-usb-0:1"),
Some("36:0"),
)
.unwrap();
draft.set_default_controller(Some("apc-mini")).unwrap();
let profile = draft.preview().unwrap();
let surface = &profile.surfaces()[0];
assert_eq!(surface.id(), "apc-mini");
assert_eq!(surface.input_port(), "APC MINI:APC MINI MIDI 1");
assert_eq!(surface.output_port(), Some("APC MINI:APC MINI MIDI 1"));
assert_eq!(surface.usb_serial(), Some("Ver00.10"));
assert_eq!(surface.manual_backend_id(), Some("36:0"));
assert_eq!(profile.default_controller(), Some("apc-mini"));
}
#[test]
fn draft_creates_an_application_group_and_fader_as_valid_toml() {
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
draft
.add_application(
"chat",
"Chat",
&[SelectorDraft {
field: SelectorField::ProcessBinary,
pattern: SelectorPattern::Exact("signal-desktop".to_owned()),
}],
)
.unwrap();
draft
.add_group("communications", "Communications", &["chat", "browser"])
.unwrap();
draft
.add_fader(
"communications-fader",
TargetKind::Group,
"communications",
true,
0.02,
)
.unwrap();
let profile = draft.preview().unwrap();
assert!(
profile
.applications()
.iter()
.any(|item| item.id() == "chat")
);
assert!(
profile
.groups()
.iter()
.any(|item| item.id() == "communications")
);
assert!(
profile
.faders()
.iter()
.any(|item| item.id() == "communications-fader")
);
ProfileDocument::parse(&draft.finish().unwrap()).unwrap();
}
#[test]
fn invalid_edits_and_referenced_deletes_roll_back_the_draft() {
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
let original = draft.source();
let invalid = draft
.add_application(
"broken",
"Broken",
&[SelectorDraft {
field: SelectorField::ApplicationName,
pattern: SelectorPattern::Regex("(".to_owned()),
}],
)
.unwrap_err();
assert!(invalid.to_string().contains("regex"));
assert_eq!(draft.source(), original);
let referenced = draft.remove_application("browser").unwrap_err();
assert!(referenced.to_string().contains("unknown application"));
assert_eq!(draft.source(), original);
}
#[test]
fn existing_applications_groups_and_faders_can_be_edited_and_deleted() {
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
draft
.set_application(
"browser",
"Web",
&[SelectorDraft {
field: SelectorField::ProcessBinary,
pattern: SelectorPattern::Exact("waterfox-bin".to_owned()),
}],
)
.unwrap();
draft.set_group("media", "Players", &["browser"]).unwrap();
draft
.set_fader(
"media-fader",
TargetKind::Application,
"browser",
false,
0.05,
)
.unwrap();
let profile = draft.preview().unwrap();
assert_eq!(profile.applications()[1].label(), "Web");
assert_eq!(profile.groups()[0].members(), &["browser"]);
assert_eq!(profile.faders()[0].target_kind(), TargetKind::Application);
assert!(!profile.faders()[0].pickup());
draft.remove_group("media").unwrap();
draft.remove_fader("media-fader").unwrap_err();
assert!(draft.source().contains("media-fader"));
}
#[test]
fn editing_group_members_preserves_the_configured_volume_mode_field() {
let source = PROFILE.replace(
"volume_mode = \"absolute\"",
"volume_mode = \"absolute\" # user-owned group mode",
);
let mut draft = ProfileDocument::parse(&source).unwrap();
draft.set_group("media", "Players", &["browser"]).unwrap();
assert!(
draft
.source()
.contains("volume_mode = \"absolute\" # user-owned group mode")
);
}
#[test]
fn draft_sets_and_unsets_the_default_controller() {
let source = PROFILE.replace("default_controller = \"desk-left\"\n", "");
let mut draft = ProfileDocument::parse(&source).unwrap();
draft.set_default_controller(Some("desk-left")).unwrap();
assert_eq!(
draft.preview().unwrap().default_controller(),
Some("desk-left")
);
let before_invalid = draft.source();
let error = draft.set_default_controller(Some("missing")).unwrap_err();
assert!(error.to_string().contains("unknown surface"));
assert_eq!(draft.source(), before_invalid);
draft.set_default_controller(None).unwrap();
assert_eq!(draft.preview().unwrap().default_controller(), None);
assert!(!draft.source().contains("default_controller"));
}
#[test]
fn draft_theme_edit_is_profile_backed() {
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
draft.set_theme(fader_config::UiTheme::Nord).unwrap();
assert_eq!(
draft.preview().unwrap().theme(),
fader_config::UiTheme::Nord
);
assert!(draft.source().contains("theme = \"nord\""));
}
#[test]
fn draft_status_display_edit_is_profile_backed() {
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
draft
.set_status_display(fader_config::StatusDisplayMode::Color)
.unwrap();
assert_eq!(
draft.preview().unwrap().status_display(),
fader_config::StatusDisplayMode::Color
);
assert!(draft.source().contains("status_display = \"color\""));
}
#[test]
fn draft_adds_bindings_and_rejects_duplicate_physical_controls() {
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
draft
.add_binding(
"desk-left",
"media-fader",
Action::Volume,
MessageKind::Cc,
1,
49,
)
.unwrap();
let before_duplicate = draft.source();
let error = draft
.add_binding(
"desk-left",
"media-fader",
Action::ToggleMute,
MessageKind::Cc,
1,
49,
)
.unwrap_err();
assert!(error.to_string().contains("duplicate physical binding"));
assert_eq!(draft.source(), before_duplicate);
}
#[test]
fn mixer_layout_draft_reorders_separators_and_retains_hidden_faders() {
let source = PROFILE.replacen(
"[[bindings]]",
"# separator comment must move with its entry\n[[mixer_layout]]\nkind = \"separator\"\nid = \"outputs\"\nlabel = \"Outputs\"\n\n[[bindings]]",
1,
);
let mut draft = ProfileDocument::parse(&source).unwrap();
draft
.set_mixer_orientation(fader_config::MixerOrientation::Horizontal)
.expect("mixer orientation must be editable");
draft
.set_fader_hidden("media-fader", true)
.expect("fader must be hidden without deletion");
draft
.set_fader_density("media-fader", fader_config::FaderDensity::Thick)
.expect("fader density must be editable");
// Real sessions reopen a saved layout: parsed tables retain source positions.
let saved = draft.finish().unwrap();
let mut draft = ProfileDocument::parse(&saved).unwrap();
draft
.move_layout_entry("media-fader", 0)
.expect("hidden fader must remain reorderable");
draft
.set_separator_label("outputs", "Main outputs")
.expect("separator label must be editable");
let profile = draft.preview().unwrap();
assert_eq!(
profile.mixer_orientation(),
fader_config::MixerOrientation::Horizontal
);
assert_eq!(
profile.mixer_layout(),
[
MixerLayoutEntry::Fader {
fader: "media-fader".to_owned(),
hidden: true,
density: fader_config::FaderDensity::Thick,
},
MixerLayoutEntry::Separator {
id: "outputs".to_owned(),
label: "Main outputs".to_owned(),
size: fader_config::SeparatorSize::Standard,
decoration: fader_config::SeparatorDecoration::Line,
},
]
);
assert_eq!(profile.faders().len(), 1, "hiding must not delete routing");
assert!(
draft
.source()
.contains("# separator comment must move with its entry")
);
draft.remove_separator("outputs").unwrap();
draft.set_fader_hidden("media-fader", false).unwrap();
assert_eq!(
draft.preview().unwrap().mixer_layout(),
[MixerLayoutEntry::Fader {
fader: "media-fader".to_owned(),
hidden: false,
density: fader_config::FaderDensity::Thick,
}]
);
}
#[test]
fn saved_layout_moves_and_insertions_survive_repeated_reloads() {
let source = format!(
"{PROFILE}\n\
[[faders]]\nid = \"other-fader\"\ntarget = {{ kind = \"group\", id = \"media\" }}\npickup = true\npickup_tolerance = 0.02\n\
# first fader comment\n[[mixer_layout]]\nkind = \"fader\"\nfader = \"media-fader\"\ndensity = \"slim\"\n\
# separator comment\n[[mixer_layout]]\nkind = \"separator\"\nid = \"heading\"\nlabel = \"Heading\"\n\
# hidden fader comment\n[[mixer_layout]]\nkind = \"fader\"\nfader = \"other-fader\"\nhidden = true\n"
);
let mut draft = ProfileDocument::parse(&source).unwrap();
let ids = |draft: &ProfileDocument| {
draft
.preview()
.unwrap()
.mixer_layout()
.iter()
.map(|entry| match entry {
MixerLayoutEntry::Fader { fader, .. } => fader.clone(),
MixerLayoutEntry::Separator { id, .. } => id.clone(),
})
.collect::<Vec<_>>()
};
for (id, position, expected) in [
("media-fader", 2, ["heading", "other-fader", "media-fader"]),
("media-fader", 0, ["media-fader", "heading", "other-fader"]),
("other-fader", 0, ["other-fader", "media-fader", "heading"]),
("heading", 1, ["other-fader", "heading", "media-fader"]),
] {
draft.move_layout_entry(id, position).unwrap();
assert_eq!(ids(&draft), expected);
draft = ProfileDocument::parse(&draft.finish().unwrap()).unwrap();
assert_eq!(ids(&draft), expected);
}
draft
.add_separator("new-heading", "New heading", 0)
.unwrap();
draft = ProfileDocument::parse(&draft.finish().unwrap()).unwrap();
assert_eq!(
ids(&draft),
["new-heading", "other-fader", "heading", "media-fader"]
);
let saved = draft.source();
for comment in [
"first fader comment",
"separator comment",
"hidden fader comment",
] {
assert_eq!(saved.matches(comment).count(), 1);
}
let profile = draft.preview().unwrap();
assert!(matches!(
&profile.mixer_layout()[1],
MixerLayoutEntry::Fader { hidden: true, .. }
));
assert!(matches!(
&profile.mixer_layout()[3],
MixerLayoutEntry::Fader {
density: fader_config::FaderDensity::Slim,
..
}
));
assert_eq!(
profile.bindings(),
fader_config::Profile::parse(PROFILE).unwrap().bindings()
);
}
#[test]
fn selector_and_binding_edits_preserve_unrelated_capture_and_actions() {
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
draft
.add_application(
"multi",
"Multi",
&[
SelectorDraft {
field: SelectorField::ApplicationName,
pattern: SelectorPattern::Exact("Old".to_owned()),
},
SelectorDraft {
field: SelectorField::MediaName,
pattern: SelectorPattern::Regex("keep-me".to_owned()),
},
],
)
.unwrap();
draft
.set_application_selector(
"multi",
0,
&SelectorDraft {
field: SelectorField::ProcessBinary,
pattern: SelectorPattern::Exact("player-bin".to_owned()),
},
)
.unwrap();
draft
.set_binding(
"desk-left",
"media-fader",
Action::Volume,
MessageKind::Cc,
1,
7,
)
.unwrap();
let before_conflict = draft.source();
let conflict = draft
.set_binding(
"desk-left",
"media-fader",
Action::ToggleMute,
MessageKind::Cc,
1,
7,
)
.unwrap_err();
assert!(conflict.to_string().contains("duplicate physical binding"));
assert_eq!(draft.source(), before_conflict);
draft
.remove_bindings("media-fader", Action::ToggleMute)
.unwrap();
let profile = draft.preview().unwrap();
let multi = profile
.applications()
.iter()
.find(|application| application.id() == "multi")
.unwrap();
assert_eq!(multi.selectors().len(), 2);
assert_eq!(multi.selectors()[0].pattern(), ("player-bin", false));
assert_eq!(multi.selectors()[1].pattern(), ("keep-me", true));
assert!(profile.bindings().iter().any(|binding| {
binding.fader() == "media-fader"
&& binding.action() == Action::Volume
&& binding.number() == 7
}));
assert!(!profile.bindings().iter().any(|binding| {
binding.fader() == "media-fader" && binding.action() == Action::ToggleMute
}));
}
#[test]
fn changing_a_mute_binding_moves_its_feedback_to_the_new_control() {
let mut draft = ProfileDocument::parse(PROFILE).unwrap();
draft
.set_binding(
"desk-left",
"media-fader",
Action::ToggleMute,
MessageKind::Note,
1,
41,
)
.unwrap();
let profile = draft.preview().unwrap();
let binding = profile
.bindings()
.iter()
.find(|binding| binding.action() == Action::ToggleMute)
.unwrap();
assert_eq!(binding.number(), 41);
let feedback = binding.feedback().expect("existing feedback is retained");
assert_eq!(feedback.number(), 41);
assert_eq!((feedback.on(), feedback.off()), (127, 0));
let independently_mapped = PROFILE.replace(
"feedback = { kind = \"note\", channel = 1, number = 32, on = 127, off = 0 }",
"feedback = { kind = \"note\", channel = 1, number = 33, on = 127, off = 0 }",
);
let mut draft = ProfileDocument::parse(&independently_mapped).unwrap();
draft
.set_binding(
"desk-left",
"media-fader",
Action::ToggleMute,
MessageKind::Note,
1,
41,
)
.unwrap();
let profile = draft.preview().unwrap();
let feedback = profile
.bindings()
.iter()
.find(|binding| binding.action() == Action::ToggleMute)
.and_then(|binding| binding.feedback())
.unwrap();
assert_eq!(feedback.number(), 33);
}