pcvolkmer/osc-variant
1
0
Fork 0
mirror of https://github.com/pcvolkmer/osc-variant.git synced 2025-04-19 19:56:50 +00:00
Code Issues

feat: make properties optional

Browse Source
This commit is contained in:
Paul-Christian Volkmer 2025-04-13 21:35:49 +02:00
parent 1d43261ab6
commit db520507ba
1 changed files with 270 additions and 367 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

637
src/model/form.rs
View File

@ -54,25 +54,32 @@ pub struct Form<Type> {
_type: PhantomData<Type>, _type: PhantomData<Type>,
#[serde(rename = "DataCatalogues")] #[serde(rename = "DataCatalogues")]
data_catalogues: DataCatalogues, #[serde(skip_serializing_if = "Option::is_none")]
data_catalogues: Option<DataCatalogues>,
#[serde(rename = "Category")] #[serde(rename = "Category")]
category: String, category: String,
#[serde(rename = "Name")] #[serde(rename = "Name")]
name: String, name: String,
#[serde(rename = "Version")] #[serde(rename = "Version")]
version: String, #[serde(skip_serializing_if = "Option::is_none")]
version: Option<String>,
#[serde(rename = "MenuEntry")] #[serde(rename = "MenuEntry")]
menu_entry: String, #[serde(skip_serializing_if = "Option::is_none")]
menu_entry: Option<String>,
#[serde(rename = "Title")] #[serde(rename = "Title")]
title: String, #[serde(skip_serializing_if = "Option::is_none")]
title: Option<String>,
#[serde(rename = "Description")] #[serde(rename = "Description")]
description: String, #[serde(skip_serializing_if = "Option::is_none")]
description: Option<String>,
#[serde(rename = "Note")] #[serde(rename = "Note")]
note: String, #[serde(skip_serializing_if = "Option::is_none")]
note: Option<String>,
#[serde(rename = "Readonly")] #[serde(rename = "Readonly")]
readonly: bool, readonly: bool,
#[serde(rename = "Active")] #[serde(rename = "Active")]
active: bool, #[serde(skip_serializing_if = "Option::is_none")]
active: Option<bool>,
#[serde(rename = "TudokPosition")] #[serde(rename = "TudokPosition")]
tudok_position: String, tudok_position: String,
#[serde(rename = "Aktenbereich")] #[serde(rename = "Aktenbereich")]
@ -85,9 +92,11 @@ pub struct Form<Type> {
#[serde(skip_serializing_if = "Option::is_none")] #[serde(skip_serializing_if = "Option::is_none")]
hotkey: Option<String>, hotkey: Option<String>,
#[serde(rename = "Summary")] #[serde(rename = "Summary")]
summary: String, #[serde(skip_serializing_if = "Option::is_none")]
summary: Option<String>,
#[serde(rename = "BigSummary")] #[serde(rename = "BigSummary")]
big_summary: String, #[serde(skip_serializing_if = "Option::is_none")]
big_summary: Option<String>,
#[serde(rename = "KalenderSchnipsel")] #[serde(rename = "KalenderSchnipsel")]
#[serde(skip_serializing_if = "Option::is_none")] #[serde(skip_serializing_if = "Option::is_none")]
kalender_schnipsel: Option<String>, kalender_schnipsel: Option<String>,
@ -184,15 +193,20 @@ pub struct Form<Type> {
#[serde(skip_serializing_if = "Option::is_none")] #[serde(skip_serializing_if = "Option::is_none")]
seitenanzahl_sichtbar: Option<bool>, seitenanzahl_sichtbar: Option<bool>,
#[serde(rename = "Entries")] #[serde(rename = "Entries")]
entries: Entries<Entry>, #[serde(skip_serializing_if = "Option::is_none")]
entries: Option<Entries<Entry>>,
#[serde(rename = "PlausibilityRules")] #[serde(rename = "PlausibilityRules")]
plausibility_rules: PlausibilityRules<DataFormEntries>, #[serde(skip_serializing_if = "Option::is_none")]
plausibility_rules: Option<PlausibilityRules<DataFormEntries>>,
#[serde(rename = "Haeufigkeiten")] #[serde(rename = "Haeufigkeiten")]
haeufigkeiten: Haeufigkeiten, #[serde(skip_serializing_if = "Option::is_none")]
haeufigkeiten: Option<Haeufigkeiten>,
#[serde(rename = "Kennzahlen")] #[serde(rename = "Kennzahlen")]
kennzahlen: Kennzahlen, #[serde(skip_serializing_if = "Option::is_none")]
kennzahlen: Option<Kennzahlen>,
#[serde(rename = "Ordner")] #[serde(rename = "Ordner")]
ordner: Ordner, #[serde(skip_serializing_if = "Option::is_none")]
ordner: Option<Ordner>,
#[serde(rename = "MenuCategory")] #[serde(rename = "MenuCategory")]
#[serde(skip_serializing_if = "Option::is_none")] #[serde(skip_serializing_if = "Option::is_none")]
menu_category: Option<MenuCategory>, menu_category: Option<MenuCategory>,
@ -208,28 +222,30 @@ impl<Type: 'static> FormEntryContainer for Form<Type> {
fn apply_profile(&mut self, profile: &Profile) { fn apply_profile(&mut self, profile: &Profile) {
profile.forms.iter().for_each(|profile_form| { profile.forms.iter().for_each(|profile_form| {
if self.name == profile_form.name { if self.name == profile_form.name {
self.entries.entry.iter_mut().for_each(|entry| { if let Some(ref mut entries) = self.entries {
profile_form entries.entry.iter_mut().for_each(|entry| {
.form_references profile_form
.iter() .form_references
.for_each(|form_reference| { .iter()
apply_profile_to_form_entry(entry, form_reference); .for_each(|form_reference| {
}); apply_profile_to_form_entry(entry, form_reference);
});
// Hide form field using filter set to "false" if requested and change default value // Hide form field using filter set to "false" if requested and change default value
profile_form profile_form
.form_fields .form_fields
.iter() .iter()
.for_each(|form_field| apply_profile_to_form_field(entry, form_field)); .for_each(|form_field| apply_profile_to_form_field(entry, form_field));
if let Some(menu_category) = &profile_form.menu_category { if let Some(menu_category) = &profile_form.menu_category {
self.menu_category = Some(MenuCategory { self.menu_category = Some(MenuCategory {
name: menu_category.name.clone(), name: menu_category.name.clone(),
position: menu_category.position.clone(), position: menu_category.position.clone(),
column: menu_category.column.clone(), column: menu_category.column.clone(),
}); });
} }
}); });
}
} }
}); });
} }
@ -261,23 +277,30 @@ impl<Type: 'static> Sortable for Form<Type> {
} }
fn sorted(&mut self) -> &Self { fn sorted(&mut self) -> &Self {
self.data_catalogues.data_catalogue.sort_unstable(); if let Some(ref mut data_catalogues) = self.data_catalogues {
data_catalogues.data_catalogue.sort_unstable();
}
self.entries.entry.sort_unstable_by_key(Entry::sorting_key); if let Some(ref mut entries) = self.entries {
entries.entry.sort_unstable_by_key(Entry::sorting_key);
self.entries.entry.iter_mut().for_each(|item| { entries.entry.iter_mut().for_each(|item| {
item.sorted(); item.sorted();
}); });
}
if let Some(ref mut plausibility_rule) = self.plausibility_rules.plausibility_rule { if let Some(ref mut plausibility_rules) = self.plausibility_rules {
plausibility_rule.sort_unstable_by_key(|item| item.bezeichnung.clone()); if let Some(ref mut plausibility_rule) = plausibility_rules.plausibility_rule {
plausibility_rule.sort_unstable_by_key(|item| item.bezeichnung.clone());
for item in plausibility_rule { for item in plausibility_rule {
if let Some(ref mut data_form_entry_names) = item.data_form_entries.entry_name { if let Some(ref mut data_form_entry_names) = item.data_form_entries.entry_name {
data_form_entry_names.sort_unstable(); data_form_entry_names.sort_unstable();
}
} }
} }
} }
self self
} }
} }
@ -315,94 +338,105 @@ where
Self: Listable + 'static, Self: Listable + 'static,
{ {
fn requires_form_reference(&self, name: &str) -> bool { fn requires_form_reference(&self, name: &str) -> bool {
self.entries if let Some(ref entries) = self.entries {
.entry entries
.iter() .entry
.map(|item| { .iter()
item.type_ == "formReference" .map(|item| {
&& match item.referenced_data_form.as_ref() { item.type_ == "formReference"
Some(refname) => refname == name, && match item.referenced_data_form.as_ref() {
_ => false, Some(refname) => refname == name,
} _ => false,
}) }
.filter(|&it| it) })
.last() .filter(|&it| it)
.unwrap_or_default() .last()
.unwrap_or_default()
} else {
false
}
} }
fn requires_subform(&self, name: &str) -> bool { fn requires_subform(&self, name: &str) -> bool {
self.entries if let Some(ref entries) = self.entries {
.entry entries
.iter() .entry
.map(|item| { .iter()
item.type_ == "subform" .map(|item| {
&& match item.referenced_data_form.as_ref() { item.type_ == "subform"
Some(refname) => refname == name, && match item.referenced_data_form.as_ref() {
_ => false, Some(refname) => refname == name,
} _ => false,
}) }
.filter(|&it| it) })
.last() .filter(|&it| it)
.unwrap_or_default() .last()
.unwrap_or_default()
} else {
false
}
} }
fn get_required_entries<'a>(&'a self, all: &'a OnkostarEditor) -> Vec<Requirement<'a>> { fn get_required_entries<'a>(&'a self, all: &'a OnkostarEditor) -> Vec<Requirement<'a>> {
let mut result = self let mut result = match self.data_catalogues {
.data_catalogues Some(ref data_catalogues) => data_catalogues
.data_catalogue .data_catalogue
.iter() .iter()
.collect::<HashSet<_>>() .collect::<HashSet<_>>()
.into_iter() .into_iter()
.map(|entry| match all.find_data_catalogue(entry.as_str()) { .map(|entry| match all.find_data_catalogue(entry.as_str()) {
Some(contained) => Requirement::DataCatalogue(contained), Some(contained) => Requirement::DataCatalogue(contained),
None => Requirement::ExternalDataCatalogue(entry.to_string()), None => Requirement::ExternalDataCatalogue(entry.to_string()),
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>(),
None => vec![],
};
result.sort_unstable_by_key(Requirement::sorting_key); result.sort_unstable_by_key(Requirement::sorting_key);
let referenced_forms = &mut self if let Some(ref entries) = self.entries {
.entries let referenced_forms = &mut entries
.entry .entry
.iter() .iter()
.filter(|&entry| entry.get_type() == "formReference") .filter(|&entry| entry.get_type() == "formReference")
.filter_map(|entry| match &entry.referenced_data_form { .filter_map(|entry| match &entry.referenced_data_form {
Some(name) => Some(name), Some(name) => Some(name),
None => None, None => None,
}) })
.collect::<HashSet<_>>() .collect::<HashSet<_>>()
.into_iter() .into_iter()
.map(|entry| match all.find_data_form(entry.as_str()) { .map(|entry| match all.find_data_form(entry.as_str()) {
Some(contained) => Requirement::DataFormReference(contained), Some(contained) => Requirement::DataFormReference(contained),
None => match all.find_unterformular(entry.as_str()) { None => match all.find_unterformular(entry.as_str()) {
Some(contained) => Requirement::UnterformularReference(contained), Some(contained) => Requirement::UnterformularReference(contained),
None => Requirement::ExternalUnterformularReference(entry.to_string()), None => Requirement::ExternalUnterformularReference(entry.to_string()),
}, },
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>();
referenced_forms.sort_unstable_by_key(Requirement::sorting_key); referenced_forms.sort_unstable_by_key(Requirement::sorting_key);
result.append(referenced_forms); result.append(referenced_forms);
let sub_forms = &mut self let sub_forms = &mut entries
.entries .entry
.entry .iter()
.iter() .filter(|&entry| entry.get_type() == "subform")
.filter(|&entry| entry.get_type() == "subform") .filter_map(|entry| match &entry.referenced_data_form {
.filter_map(|entry| match &entry.referenced_data_form { Some(name) => Some(name),
Some(name) => Some(name), None => None,
None => None, })
}) .collect::<HashSet<_>>()
.collect::<HashSet<_>>() .into_iter()
.into_iter() .map(|entry| match all.find_data_form(entry.as_str()) {
.map(|entry| match all.find_data_form(entry.as_str()) { Some(contained) => Requirement::DataFormSubform(contained),
Some(contained) => Requirement::DataFormSubform(contained), None => match all.find_unterformular(entry.as_str()) {
None => match all.find_unterformular(entry.as_str()) { Some(contained) => Requirement::UnterformularSubform(contained),
Some(contained) => Requirement::UnterformularSubform(contained), None => Requirement::ExternalUnterformularSubform(entry.to_string()),
None => Requirement::ExternalUnterformularSubform(entry.to_string()), },
}, })
}) .collect::<Vec<_>>();
.collect::<Vec<_>>(); sub_forms.sort_unstable_by_key(Requirement::sorting_key);
sub_forms.sort_unstable_by_key(Requirement::sorting_key); result.append(sub_forms);
result.append(sub_forms); }
result result
} }
@ -410,19 +444,26 @@ where
impl<Type: 'static> FolderContent for Form<Type> { impl<Type: 'static> FolderContent for Form<Type> {
fn get_library_folder(&self) -> String { fn get_library_folder(&self) -> String {
self.ordner.bibliothek.name.to_string() match &self.ordner {
Some(ordner) => ordner.bibliothek.name.to_string(),
None => String::new(),
}
} }
} }
impl<Type> Form<Type> { impl<Type> Form<Type> {
fn common_check(&self) -> Vec<CheckNotice> { fn common_check(&self) -> Vec<CheckNotice> {
let missing_forms = self let missing_forms = match self.entries {
.entries Some(ref entries) => entries
.entry .entry
.iter() .iter()
.filter(|entry| entry.type_ == "formReference" && entry.referenced_data_form.is_none()) .filter(|entry| {
.map(|entry| format!("'{}'", entry.get_name())) entry.type_ == "formReference" && entry.referenced_data_form.is_none()
.collect::<Vec<_>>(); })
.map(|entry| format!("'{}'", entry.get_name()))
.collect::<Vec<_>>(),
None => vec![],
};
let mut result = vec![]; let mut result = vec![];
@ -445,25 +486,29 @@ impl<Type> Form<Type> {
impl Checkable for Form<DataFormType> { impl Checkable for Form<DataFormType> {
fn check(&self) -> Vec<CheckNotice> { fn check(&self) -> Vec<CheckNotice> {
let mut result = if self let mut result = match self.entries {
.entries Some(ref entries) => {
.entry if entries
.iter() .entry
.filter(|entry| entry.procedure_date_status != "none") .iter()
.count() .filter(|entry| entry.procedure_date_status != "none")
== 0 .count()
{ == 0
vec![ErrorWithCode { {
code: "2023-0002".to_string(), vec![ErrorWithCode {
description: format!( code: "2023-0002".to_string(),
"Formular '{}' hat keine Angabe zum Prozedurdatum", description: format!(
self.name "Formular '{}' hat keine Angabe zum Prozedurdatum",
), self.name
line: None, ),
example: None, line: None,
}] example: None,
} else { }]
vec![] } else {
vec![]
}
}
None => vec![],
}; };
result.append(&mut self.common_check()); result.append(&mut self.common_check());
@ -516,7 +561,7 @@ mod tests {
use std::str::FromStr; use std::str::FromStr;
use crate::model::onkostar_editor::OnkostarEditor; use crate::model::onkostar_editor::OnkostarEditor;
use crate::model::{Filter, RefEntries, Script}; use crate::model::Script;
use crate::profile::Profile; use crate::profile::Profile;
#[test] #[test]
@ -537,25 +582,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].name,
"Auswahl"
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].default_value,
""
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let Some(actual) = &onkostar_editor.editor.data_form[0].entries else {
onkostar_editor.editor.data_form[0].entries.entry[2].name, panic!()
"Auswahl" };
);
assert_eq!( assert_eq!(actual.entry[2].name, "Auswahl");
onkostar_editor.editor.data_form[0].entries.entry[2].default_value, assert_eq!(actual.entry[2].default_value, "B");
"B"
);
} }
#[test] #[test]
@ -573,25 +607,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].name,
"Auswahl"
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].default_value,
""
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let Some(actual) = &onkostar_editor.editor.data_form[0].entries else {
onkostar_editor.editor.data_form[0].entries.entry[2].name, panic!()
"Auswahl" };
);
assert_eq!( assert_eq!(actual.entry[2].name, "Auswahl");
onkostar_editor.editor.data_form[0].entries.entry[2].default_value, assert_eq!(actual.entry[2].default_value, "");
""
);
} }
#[test] #[test]
@ -664,15 +687,15 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].scripts,
None
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
let actual = match &onkostar_editor.editor.data_form[0].entries {
Some(entries) => entries,
None => panic!(),
};
assert_eq!( assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].scripts, actual.entry[2].scripts,
Some(Script { Some(Script {
code: "// Example code&#10;console.log(42);".into(), code: "// Example code&#10;console.log(42);".into(),
valid: true valid: true
@ -700,15 +723,15 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].scripts,
None
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
let actual = match &onkostar_editor.editor.data_form[0].entries {
Some(entries) => entries,
None => panic!(),
};
assert_eq!( assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].scripts, actual.entry[2].scripts,
Some(Script { Some(Script {
code: "// Example code&#10;console.log(42);".into(), code: "// Example code&#10;console.log(42);".into(),
valid: true valid: true
@ -737,51 +760,20 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[0].filter,
None
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[1].filter,
None
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].filter,
Some(Filter {
condition: "getGlobalSetting('mehrere_mtb_in_mtbepisode') = 'true'".into(),
valid: true,
ref_entries: Some(RefEntries { ref_entry: None })
})
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[3].filter,
None
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let actual = match &onkostar_editor.editor.data_form[0].entries {
onkostar_editor.editor.data_form[0].entries.entry[0].filter, Some(entries) => entries,
None None => panic!(),
); };
assert_eq!( assert_eq!(actual.entry[0].filter, None);
onkostar_editor.editor.data_form[0].entries.entry[1].filter,
None
);
assert_eq!( assert_eq!(actual.entry[1].filter, None);
onkostar_editor.editor.data_form[0].entries.entry[2].filter,
None
);
assert_eq!( assert_eq!(actual.entry[2].filter, None);
onkostar_editor.editor.data_form[0].entries.entry[3].filter,
None assert_eq!(actual.entry[3].filter, None);
);
} }
#[test] #[test]
@ -805,51 +797,20 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[0].filter,
None
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[1].filter,
None
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].filter,
Some(Filter {
condition: "getGlobalSetting('mehrere_mtb_in_mtbepisode') = 'true'".into(),
valid: true,
ref_entries: Some(RefEntries { ref_entry: None })
})
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[3].filter,
None
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let actual = match &onkostar_editor.editor.data_form[0].entries {
onkostar_editor.editor.data_form[0].entries.entry[0].filter, Some(entries) => entries,
None None => panic!(),
); };
assert_eq!( assert_eq!(actual.entry[0].filter, None);
onkostar_editor.editor.data_form[0].entries.entry[1].filter,
None
);
assert_eq!( assert_eq!(actual.entry[1].filter, None);
onkostar_editor.editor.data_form[0].entries.entry[2].filter,
None
);
assert_eq!( assert_eq!(actual.entry[2].filter, None);
onkostar_editor.editor.data_form[0].entries.entry[3].filter,
None assert_eq!(actual.entry[3].filter, None);
);
} }
#[test] #[test]
@ -870,25 +831,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].name,
"Termin"
);
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].default_value,
""
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let Some(actual) = &onkostar_editor.editor.unterformular[0].entries else {
onkostar_editor.editor.unterformular[0].entries.entry[1].name, panic!()
"Termin" };
);
assert_eq!( assert_eq!(actual.entry[1].name, "Termin");
onkostar_editor.editor.unterformular[0].entries.entry[1].default_value, assert_eq!(actual.entry[1].default_value, "2024-03-18");
"2024-03-18"
);
} }
#[test] #[test]
@ -906,25 +856,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].name,
"Termin"
);
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].default_value,
""
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let Some(actual) = &onkostar_editor.editor.unterformular[0].entries else {
onkostar_editor.editor.unterformular[0].entries.entry[1].name, panic!()
"Termin" };
);
assert_eq!( assert_eq!(actual.entry[1].name, "Termin");
onkostar_editor.editor.unterformular[0].entries.entry[1].default_value, assert_eq!(actual.entry[1].default_value, "");
""
);
} }
#[test] #[test]
@ -969,15 +908,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].scripts,
None
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
let Some(actual) = &onkostar_editor.editor.unterformular[0].entries else {
panic!()
};
assert_eq!( assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].scripts, actual.entry[1].scripts,
Some(Script { Some(Script {
code: "// Example code&#10;console.log(42);".into(), code: "// Example code&#10;console.log(42);".into(),
valid: true valid: true
@ -1005,15 +943,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].scripts,
None
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
let Some(actual) = &onkostar_editor.editor.unterformular[0].entries else {
panic!()
};
assert_eq!( assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].scripts, actual.entry[1].scripts,
Some(Script { Some(Script {
code: "// Example code&#10;console.log(42);".into(), code: "// Example code&#10;console.log(42);".into(),
valid: true valid: true
@ -1042,31 +979,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[0].filter,
None
);
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].filter,
Some(Filter {
condition: "getGlobalSetting('mehrere_mtb_in_mtbepisode') = 'true'".into(),
valid: true,
ref_entries: Some(RefEntries { ref_entry: None })
})
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let Some(actual) = &onkostar_editor.editor.unterformular[0].entries else {
onkostar_editor.editor.unterformular[0].entries.entry[0].filter, panic!()
None };
);
assert_eq!( assert_eq!(actual.entry[0].filter, None);
onkostar_editor.editor.unterformular[0].entries.entry[1].filter, assert_eq!(actual.entry[1].filter, None);
None
);
} }
#[test] #[test]
@ -1090,30 +1010,13 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[0].filter,
None
);
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].filter,
Some(Filter {
condition: "getGlobalSetting('mehrere_mtb_in_mtbepisode') = 'true'".into(),
valid: true,
ref_entries: Some(RefEntries { ref_entry: None })
})
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let Some(actual) = &onkostar_editor.editor.unterformular[0].entries else {
onkostar_editor.editor.unterformular[0].entries.entry[0].filter, panic!()
None };
);
assert_eq!( assert_eq!(actual.entry[0].filter, None);
onkostar_editor.editor.unterformular[0].entries.entry[1].filter, assert_eq!(actual.entry[1].filter, None);
None
);
} }
} }