fixes oxidecomputer#589 allow min and max to be within range

typify-impl/src/convert.rs

@@ -1011,14 +1011,14 @@ impl TypeSpace {
         ];
 
         if let Some(format) = format {
-            if let Some((_, ty, imin, imax)) = formats
+            if let Some((_fmt, ty, imin, imax)) = formats
                 .iter()
                 .find(|(int_format, _, _, _)| int_format == format)
             {
                 // If the type matches with other constraints, we're done.
                 if multiple.is_none()
-                    && (min.is_none() || min == Some(*imin))
-                    && (max.is_none() || max == Some(*imax))
+                    && (min.map(|f| f.ge(imin)).unwrap_or(false))
+                    && (max.map(|f| f.le(imax)).unwrap_or(false))
                 {
                     // If there's a default value and it's either not a number
                     // or outside of the range for this format, return an
@@ -2001,6 +2001,7 @@ mod tests {
         test_util::validate_output, validate_builtin, Error, Name, TypeSpace, TypeSpaceImpl,
         TypeSpaceSettings,
     };
+    use crate::type_entry::TypeEntryDetails;
 
     #[track_caller]
     fn int_helper<T: JsonSchema>(type_name: &'static str) {
@@ -2115,6 +2116,35 @@ mod tests {
         validate_builtin!(std::collections::BTreeSet<u32>);
     }
 
+    #[test]
+    fn test_uint_minimum_and_maximum() {
+        let schema = SchemaObject {
+            instance_type: Some(InstanceType::Integer.into()),
+            format: Some("uint64".to_string()),
+            metadata: None,
+            number: Some(
+                NumberValidation {
+                    minimum: Some(0.),
+                    maximum: Some(256.0),
+                    ..Default::default()
+                }
+                    .into(),
+            ),
+            ..Default::default()
+        };
+
+        let mut type_space = TypeSpace::default();
+        match type_space.convert_schema_object(
+            Name::Unknown,
+            &schemars::schema::Schema::Object(schema.clone()),
+            &schema,
+        ) {
+            Ok((te, _ob)) => {
+                assert_eq!(te.details, TypeEntryDetails::Integer("u64".to_string()));
+            },
+            _ => panic!("unexpected result"),
+        }
+    }
     #[test]
     fn test_low_default() {
         let schema = SchemaObject {