24391614752

Committed 14 Apr 2026 09:30AM UTC coverage: 87.527% (+0.1%) from 87.39%

Build # 24391614752

Build Type

push

github

Committed by

web-flow

Commit Message

fix: openapi enum variant names (#1139)

* fix openapi enum variant names

* fix degenerated openapi enum names OneOf

Coverage Stats

263 of 267 new or added lines in 4 files covered. (98.5%)

6 existing lines in 3 files now uncovered.

114087 of 130345 relevant lines covered (87.53%)

496692.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.37

/geoengine/services/src/api/model/processing_graphs/source_parameters.rs

use crate::api::model::processing_graphs::{RasterOperator, VectorOperator};
use serde::{Deserialize, Serialize};
use utoipa::ToSchema;

/// A single raster operator as a source for this operator.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
#[schema(no_recursion)]
#[serde(rename_all = "camelCase")]
pub struct SingleRasterSource {
    pub raster: RasterOperator,
}

impl TryFrom<SingleRasterSource> for geoengine_operators::engine::SingleRasterSource {
    type Error = anyhow::Error;

    fn try_from(value: SingleRasterSource) -> Result<Self, Self::Error> {
        Ok(Self {
            raster: value.raster.try_into()?,
        })
    }
}

/// One or more raster operators as sources for this operator.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
#[schema(no_recursion)]
#[serde(rename_all = "camelCase")]
pub struct MultipleRasterSources {
    pub rasters: Vec<RasterOperator>,
}

impl TryFrom<MultipleRasterSources> for geoengine_operators::engine::MultipleRasterSources {
    type Error = anyhow::Error;

    fn try_from(value: MultipleRasterSources) -> Result<Self, Self::Error> {
        Ok(Self {
            rasters: value
                .rasters
                .into_iter()
                .map(std::convert::TryInto::try_into)
                .collect::<Result<_, _>>()?,
        })
    }
}

/// A single vector operator or a single raster operators as source for this operator.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
#[schema(no_recursion)]
#[serde(rename_all = "camelCase")]
pub struct SingleRasterOrVectorSource {
    pub source: SingleRasterOrVectorOperator,
}

/// It is either a set of `RasterOperator` or a single `VectorOperator`
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
#[serde(untagged)]
pub enum SingleRasterOrVectorOperator {
    Raster(RasterOperator),
    Vector(VectorOperator),
}

impl TryFrom<SingleRasterOrVectorSource>
    for geoengine_operators::engine::SingleRasterOrVectorSource
{
    type Error = anyhow::Error;

    fn try_from(value: SingleRasterOrVectorSource) -> Result<Self, Self::Error> {
        use geoengine_operators::util::input::RasterOrVectorOperator as OperatorsRasterOrVectorOperator;
        let source = match value.source {
            SingleRasterOrVectorOperator::Raster(raster) => {
                OperatorsRasterOrVectorOperator::Raster(raster.try_into()?)
            }
            SingleRasterOrVectorOperator::Vector(vector) => {
                OperatorsRasterOrVectorOperator::Vector(vector.try_into()?)
            }
        };
        Ok(Self { source })
    }
}

/// A single vector or raster operator as source for this operator, keyed as "vector" in JSON.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
#[schema(no_recursion)]
#[serde(rename_all = "camelCase")]
pub struct SingleVectorOrRasterSource {
    pub vector: SingleRasterOrVectorOperator,
}

impl TryFrom<SingleVectorOrRasterSource>
    for geoengine_operators::engine::SingleRasterOrVectorSource
{
    type Error = anyhow::Error;

    fn try_from(value: SingleVectorOrRasterSource) -> Result<Self, Self::Error> {
        use geoengine_operators::util::input::RasterOrVectorOperator as OperatorsRasterOrVectorOperator;
        let source = match value.vector {
            SingleRasterOrVectorOperator::Raster(raster) => {
                OperatorsRasterOrVectorOperator::Raster(raster.try_into()?)
            }
            SingleRasterOrVectorOperator::Vector(vector) => {
                OperatorsRasterOrVectorOperator::Vector(vector.try_into()?)
            }
        };
        Ok(Self { source })
    }
}

/// A single vector operator and one or more raster operators as source for this operator.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
#[schema(no_recursion)]
#[serde(rename_all = "camelCase")]
pub struct SingleVectorMultipleRasterSources {
    pub vector: VectorOperator,
    pub rasters: Vec<RasterOperator>,
}

impl TryFrom<SingleVectorMultipleRasterSources>
    for geoengine_operators::engine::SingleVectorMultipleRasterSources
{
    type Error = anyhow::Error;

    fn try_from(value: SingleVectorMultipleRasterSources) -> Result<Self, Self::Error> {
        Ok(Self {
            vector: value.vector.try_into()?,
            rasters: value
                .rasters
                .into_iter()
                .map(std::convert::TryInto::try_into)
                .collect::<Result<_, _>>()?,
        })
    }
}

/// Either one or more raster operators or a single vector operator as source for this operator.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct MultipleRasterOrSingleVectorSource {
    pub source: MultipleRasterOrSingleVectorOperator,
}

/// It is either a set of `RasterOperator` or a single `VectorOperator`
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
#[serde(untagged)]
pub enum MultipleRasterOrSingleVectorOperator {
    Raster(Vec<RasterOperator>),
    Vector(VectorOperator),
}

impl TryFrom<MultipleRasterOrSingleVectorSource>
    for geoengine_operators::engine::MultipleRasterOrSingleVectorSource
{
    type Error = anyhow::Error;

    fn try_from(value: MultipleRasterOrSingleVectorSource) -> Result<Self, Self::Error> {
        use geoengine_operators::util::input::MultiRasterOrVectorOperator as OperatorsMultiRasterOrVectorOperator;
        let source = match value.source {
            MultipleRasterOrSingleVectorOperator::Raster(rasters) => {
                OperatorsMultiRasterOrVectorOperator::Raster(
                    rasters
                        .into_iter()
                        .map(std::convert::TryInto::try_into)
                        .collect::<Result<_, _>>()?,
                )
            }
            MultipleRasterOrSingleVectorOperator::Vector(vector) => {
                OperatorsMultiRasterOrVectorOperator::Vector(vector.try_into()?)
            }
        };
        Ok(Self { source })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::api::model::processing_graphs::parameters::SpatialBoundsDerive;
    use crate::api::model::processing_graphs::source::{
        GdalSource, GdalSourceParameters, MockPointSource, MockPointSourceParameters,
    };
    use crate::api::model::processing_graphs::{RasterOperator, VectorOperator};

    #[test]
    fn it_converts_single_raster_source() {
        let api = SingleRasterSource {
            raster: RasterOperator::GdalSource(GdalSource {
                r#type: Default::default(),
                params: GdalSourceParameters {
                    data: "example_data".to_string(),
                    overview_level: None,
                },
            }),
        };

        let _eng: geoengine_operators::engine::SingleRasterSource =
            api.try_into().expect("conversion failed");
    }

    #[test]
    fn it_converts_multiple_raster_sources() {
        let api = MultipleRasterSources {
            rasters: vec![RasterOperator::GdalSource(GdalSource {
                r#type: Default::default(),
                params: GdalSourceParameters {
                    data: "example_data".to_string(),
                    overview_level: None,
                },
            })],
        };

        let eng: geoengine_operators::engine::MultipleRasterSources =
            api.try_into().expect("conversion failed");

        assert_eq!(eng.rasters.len(), 1);
    }

    #[test]
    fn it_converts_single_raster_or_vector_source() {
        let api = SingleRasterOrVectorSource {
            source: SingleRasterOrVectorOperator::Raster(RasterOperator::GdalSource(GdalSource {
                r#type: Default::default(),
                params: GdalSourceParameters {
                    data: "example_data".to_string(),
                    overview_level: None,
                },
            })),
        };

        let eng: geoengine_operators::engine::SingleRasterOrVectorSource =
            api.try_into().expect("conversion failed");

        assert!(eng.raster().is_some());
    }

    #[test]
    fn it_converts_single_vector_multiple_raster_sources() {
        let api = SingleVectorMultipleRasterSources {
            vector: VectorOperator::MockPointSource(MockPointSource {
                r#type: Default::default(),
                params: MockPointSourceParameters {
                    points: vec![crate::api::model::datatypes::Coordinate2D { x: 0.0, y: 0.0 }],
                    spatial_bounds: SpatialBoundsDerive::Derive(Default::default()),
                },
            }),
            rasters: vec![RasterOperator::GdalSource(GdalSource {
                r#type: Default::default(),
                params: GdalSourceParameters {
                    data: "example_data".to_string(),
                    overview_level: None,
                },
            })],
        };

        let eng: geoengine_operators::engine::SingleVectorMultipleRasterSources =
            api.try_into().expect("conversion failed");

        assert_eq!(eng.rasters.len(), 1);
    }

    #[test]
    fn it_converts_multiple_raster_or_single_vector_source() {
        let api = MultipleRasterOrSingleVectorSource {
            source: MultipleRasterOrSingleVectorOperator::Raster(vec![RasterOperator::GdalSource(
                GdalSource {
                    r#type: Default::default(),
                    params: GdalSourceParameters {
                        data: "example_data".to_string(),
                        overview_level: None,
                    },
                },
            )]),
        };

        let eng: geoengine_operators::engine::MultipleRasterOrSingleVectorSource =
            api.try_into().expect("conversion failed");

        assert!(eng.raster().is_some());
    }
}

1	use crate::api::model::processing_graphs::{RasterOperator, VectorOperator};
2	use serde::{Deserialize, Serialize};
3	use utoipa::ToSchema;
4
5	/// A single raster operator as a source for this operator.
6	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
7	#[schema(no_recursion)]
8	#[serde(rename_all = "camelCase")]
9	pub struct SingleRasterSource {
10	pub raster: RasterOperator,
11	}
12
13	impl TryFrom<SingleRasterSource> for geoengine_operators::engine::SingleRasterSource {
14	type Error = anyhow::Error;
15
16	fn try_from(value: SingleRasterSource) -> Result<Self, Self::Error> {	6✔
17	Ok(Self {
18	raster: value.raster.try_into()?,	6✔
19	})
20	}	6✔
21	}
22
23	/// One or more raster operators as sources for this operator.
24	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
25	#[schema(no_recursion)]
26	#[serde(rename_all = "camelCase")]
27	pub struct MultipleRasterSources {
28	pub rasters: Vec<RasterOperator>,
29	}
30
31	impl TryFrom<MultipleRasterSources> for geoengine_operators::engine::MultipleRasterSources {
32	type Error = anyhow::Error;
33
34	fn try_from(value: MultipleRasterSources) -> Result<Self, Self::Error> {	4✔
35	Ok(Self {
36	rasters: value	4✔
37	.rasters	4✔
38	.into_iter()	4✔
39	.map(std::convert::TryInto::try_into)	4✔
40	.collect::<Result<_, _>>()?,	4✔
41	})
42	}	4✔
43	}
44
45	/// A single vector operator or a single raster operators as source for this operator.
46	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
47	#[schema(no_recursion)]
48	#[serde(rename_all = "camelCase")]
49	pub struct SingleRasterOrVectorSource {
50	pub source: SingleRasterOrVectorOperator,
51	}
52
53	/// It is either a set of `RasterOperator` or a single `VectorOperator`
54	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
55	#[serde(untagged)]
56	pub enum SingleRasterOrVectorOperator {
57	Raster(RasterOperator),
58	Vector(VectorOperator),
59	}
60
61	impl TryFrom<SingleRasterOrVectorSource>
62	for geoengine_operators::engine::SingleRasterOrVectorSource
63	{
64	type Error = anyhow::Error;
65
66	fn try_from(value: SingleRasterOrVectorSource) -> Result<Self, Self::Error> {	3✔
67	use geoengine_operators::util::input::RasterOrVectorOperator as OperatorsRasterOrVectorOperator;
68	let source = match value.source {	3✔
69	SingleRasterOrVectorOperator::Raster(raster) => {	2✔
70	OperatorsRasterOrVectorOperator::Raster(raster.try_into()?)	2✔
71	}
72	SingleRasterOrVectorOperator::Vector(vector) => {	1✔
73	OperatorsRasterOrVectorOperator::Vector(vector.try_into()?)	1✔
74	}
75	};
76	Ok(Self { source })	3✔
77	}	3✔
78	}
79
80	/// A single vector or raster operator as source for this operator, keyed as "vector" in JSON.
81	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
82	#[schema(no_recursion)]
83	#[serde(rename_all = "camelCase")]
84	pub struct SingleVectorOrRasterSource {
85	pub vector: SingleRasterOrVectorOperator,
86	}
87
88	impl TryFrom<SingleVectorOrRasterSource>
89	for geoengine_operators::engine::SingleRasterOrVectorSource
90	{
91	type Error = anyhow::Error;
92
93	fn try_from(value: SingleVectorOrRasterSource) -> Result<Self, Self::Error> {	2✔
94	use geoengine_operators::util::input::RasterOrVectorOperator as OperatorsRasterOrVectorOperator;
95	let source = match value.vector {	2✔
NEW 96	SingleRasterOrVectorOperator::Raster(raster) => {	×
NEW 97	OperatorsRasterOrVectorOperator::Raster(raster.try_into()?)	×
98	}
99	SingleRasterOrVectorOperator::Vector(vector) => {	2✔
100	OperatorsRasterOrVectorOperator::Vector(vector.try_into()?)	2✔
101	}
102	};
103	Ok(Self { source })	2✔
104	}	2✔
105	}
106
107	/// A single vector operator and one or more raster operators as source for this operator.
108	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
109	#[schema(no_recursion)]
110	#[serde(rename_all = "camelCase")]
111	pub struct SingleVectorMultipleRasterSources {
112	pub vector: VectorOperator,
113	pub rasters: Vec<RasterOperator>,
114	}
115
116	impl TryFrom<SingleVectorMultipleRasterSources>
117	for geoengine_operators::engine::SingleVectorMultipleRasterSources
118	{
119	type Error = anyhow::Error;
120
121	fn try_from(value: SingleVectorMultipleRasterSources) -> Result<Self, Self::Error> {	3✔
122	Ok(Self {
123	vector: value.vector.try_into()?,	3✔
124	rasters: value	3✔
125	.rasters	3✔
126	.into_iter()	3✔
127	.map(std::convert::TryInto::try_into)	3✔
128	.collect::<Result<_, _>>()?,	3✔
129	})
130	}	3✔
131	}
132
133	/// Either one or more raster operators or a single vector operator as source for this operator.
134	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
135	#[serde(rename_all = "camelCase")]
136	pub struct MultipleRasterOrSingleVectorSource {
137	pub source: MultipleRasterOrSingleVectorOperator,
138	}
139
140	/// It is either a set of `RasterOperator` or a single `VectorOperator`
141	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
142	#[serde(untagged)]
143	pub enum MultipleRasterOrSingleVectorOperator {
144	Raster(Vec<RasterOperator>),
145	Vector(VectorOperator),
146	}
147
148	impl TryFrom<MultipleRasterOrSingleVectorSource>
149	for geoengine_operators::engine::MultipleRasterOrSingleVectorSource
150	{
151	type Error = anyhow::Error;
152
153	fn try_from(value: MultipleRasterOrSingleVectorSource) -> Result<Self, Self::Error> {	5✔
154	use geoengine_operators::util::input::MultiRasterOrVectorOperator as OperatorsMultiRasterOrVectorOperator;
155	let source = match value.source {	5✔
156	MultipleRasterOrSingleVectorOperator::Raster(rasters) => {	3✔
157	OperatorsMultiRasterOrVectorOperator::Raster(
158	rasters	3✔
159	.into_iter()	3✔
160	.map(std::convert::TryInto::try_into)	3✔
161	.collect::<Result<_, _>>()?,	3✔
162	)
163	}
164	MultipleRasterOrSingleVectorOperator::Vector(vector) => {	2✔
165	OperatorsMultiRasterOrVectorOperator::Vector(vector.try_into()?)	2✔
166	}
167	};
168	Ok(Self { source })	5✔
169	}	5✔
170	}
171
172	#[cfg(test)]
173	mod tests {
174	use super::*;
175	use crate::api::model::processing_graphs::parameters::SpatialBoundsDerive;
176	use crate::api::model::processing_graphs::source::{
177	GdalSource, GdalSourceParameters, MockPointSource, MockPointSourceParameters,
178	};
179	use crate::api::model::processing_graphs::{RasterOperator, VectorOperator};
180
181	#[test]
182	fn it_converts_single_raster_source() {	1✔
183	let api = SingleRasterSource {	1✔
184	raster: RasterOperator::GdalSource(GdalSource {	1✔
185	r#type: Default::default(),	1✔
186	params: GdalSourceParameters {	1✔
187	data: "example_data".to_string(),	1✔
188	overview_level: None,	1✔
189	},	1✔
190	}),	1✔
191	};	1✔
192
193	let _eng: geoengine_operators::engine::SingleRasterSource =	1✔
194	api.try_into().expect("conversion failed");	1✔
195	}	1✔
196
197	#[test]
198	fn it_converts_multiple_raster_sources() {	1✔
199	let api = MultipleRasterSources {	1✔
200	rasters: vec![RasterOperator::GdalSource(GdalSource {	1✔
201	r#type: Default::default(),	1✔
202	params: GdalSourceParameters {	1✔
203	data: "example_data".to_string(),	1✔
204	overview_level: None,	1✔
205	},	1✔
206	})],	1✔
207	};	1✔
208
209	let eng: geoengine_operators::engine::MultipleRasterSources =	1✔
210	api.try_into().expect("conversion failed");	1✔
211
212	assert_eq!(eng.rasters.len(), 1);	1✔
213	}	1✔
214
215	#[test]
216	fn it_converts_single_raster_or_vector_source() {	1✔
217	let api = SingleRasterOrVectorSource {	1✔
218	source: SingleRasterOrVectorOperator::Raster(RasterOperator::GdalSource(GdalSource {	1✔
219	r#type: Default::default(),	1✔
220	params: GdalSourceParameters {	1✔
221	data: "example_data".to_string(),	1✔
222	overview_level: None,	1✔
223	},	1✔
224	})),	1✔
225	};	1✔
226
227	let eng: geoengine_operators::engine::SingleRasterOrVectorSource =	1✔
228	api.try_into().expect("conversion failed");	1✔
229
230	assert!(eng.raster().is_some());	1✔
231	}	1✔
232
233	#[test]
234	fn it_converts_single_vector_multiple_raster_sources() {	1✔
235	let api = SingleVectorMultipleRasterSources {	1✔
236	vector: VectorOperator::MockPointSource(MockPointSource {	1✔
237	r#type: Default::default(),	1✔
238	params: MockPointSourceParameters {	1✔
239	points: vec![crate::api::model::datatypes::Coordinate2D { x: 0.0, y: 0.0 }],	1✔
240	spatial_bounds: SpatialBoundsDerive::Derive(Default::default()),	1✔
241	},	1✔
242	}),	1✔
243	rasters: vec![RasterOperator::GdalSource(GdalSource {	1✔
244	r#type: Default::default(),	1✔
245	params: GdalSourceParameters {	1✔
246	data: "example_data".to_string(),	1✔
247	overview_level: None,	1✔
248	},	1✔
249	})],	1✔
250	};	1✔
251
252	let eng: geoengine_operators::engine::SingleVectorMultipleRasterSources =	1✔
253	api.try_into().expect("conversion failed");	1✔
254
255	assert_eq!(eng.rasters.len(), 1);	1✔
256	}	1✔
257
258	#[test]
259	fn it_converts_multiple_raster_or_single_vector_source() {	1✔
260	let api = MultipleRasterOrSingleVectorSource {	1✔
261	source: MultipleRasterOrSingleVectorOperator::Raster(vec![RasterOperator::GdalSource(	1✔
262	GdalSource {	1✔
263	r#type: Default::default(),	1✔
264	params: GdalSourceParameters {	1✔
265	data: "example_data".to_string(),	1✔
266	overview_level: None,	1✔
267	},	1✔
268	},	1✔
269	)]),	1✔
270	};	1✔
271
272	let eng: geoengine_operators::engine::MultipleRasterOrSingleVectorSource =	1✔
273	api.try_into().expect("conversion failed");	1✔
274
275	assert!(eng.raster().is_some());	1✔
276	}	1✔
277	}

geo-engine / geoengine / 24391614752

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous