(GH-642) Add initial plumbing for validating schema URIs

Prior to this change, DSC didn't have a convenient way to verify
whether a configuration or manifest used a recognized schema or
to switch behaviors based on the declared URI.

This change begins the process of plumbing the recognized schemas
into DSC so the engine can correctly validate and handle items
based on the value of the `$schema` keyword. In this first
iteration, the `DscRepoSchema` trait adds a method to validate
whether the item uses a recognized schema. In the future, the
engine should provide further handling than pass/fail.

This change only adds the methods, it doesn't alter how DSC
processes configuration documents or resource manifests.

Author: michaeltlombardi

dsc_lib/locales/en-us.toml

@@ -319,7 +319,9 @@ schemaNotAvailable = "No Schema found and `validate` is not supported"
 securityContext = "Security context"
 utf8Conversion = "UTF-8 conversion"
 unknown = "Unknown"
+unrecognizedSchemaUri = "Unrecognized $schema URI"
 validation = "Validation"
+validSchemaUrisAre = "Valid schema URIs are"
 setting = "Setting"
 
 [progress]

dsc_lib/src/configure/config_doc.rs

@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 use std::collections::HashMap;
 
-use crate::schemas::DscRepoSchema;
+use crate::{dscerror::DscError, schemas::DscRepoSchema};
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
@@ -165,6 +165,16 @@ impl DscRepoSchema for Configuration {
             ..Default::default()
         }
     }
+
+    fn validate_schema_uri(&self) -> Result<(), DscError> {
+        match Self::is_recognized_schema_uri(&self.schema) {
+            true => Ok(()),
+            false => Err(DscError::UnrecognizedSchemaUri(
+                self.schema.clone(),
+                Self::recognized_schema_uris(),
+            ))
+        }
+    }
 }
 
 impl Configuration {
@@ -199,3 +209,46 @@ impl Default for Resource {
         Self::new()
     }
 }
+
+#[allow(unused_imports)]
+mod test {
+    use serde_json::json;
+
+    use crate::{configure::config_doc::Configuration, dscerror::DscError, dscresources::resource_manifest::{import_manifest, ResourceManifest}, schemas::DscRepoSchema};
+
+    #[test]
+    fn test_validate_schema_uri_with_invalid_uri() {
+        let invalid_uri = "https://invalid.schema.uri".to_string();
+
+        let manifest = Configuration{
+            schema: invalid_uri.clone(),
+            ..Default::default()
+        };
+
+        let ref result = manifest.validate_schema_uri();
+
+        assert!(result.as_ref().is_err());
+
+        match result.as_ref().unwrap_err() {
+            DscError::UnrecognizedSchemaUri(actual, recognized) => {
+                assert_eq!(actual, &invalid_uri);
+                assert_eq!(recognized, &Configuration::recognized_schema_uris())
+            },
+            _ => {
+                panic!("Expected validate_schema_uri() to error on unrecognized schema uri, but was {:?}", result.as_ref().unwrap_err())
+            }
+        }
+    }
+
+    #[test]
+    fn test_validate_schema_uri_with_valid_uri() {
+        let manifest = Configuration{
+            schema: Configuration::default_schema_id_uri(),
+            ..Default::default()
+        };
+
+        let result = manifest.validate_schema_uri();
+
+        assert!(result.is_ok());
+    }
+}

dsc_lib/src/dscerror.rs

@@ -113,6 +113,9 @@ pub enum DscError {
         message: String,
     },
 
+    #[error("{t}: {0}.  {t2}: {1:?}", t = t!("dscerror.unrecognizedSchemaUri"), t2 = t!("dscerror.validSchemaUrisAre"))]
+    UnrecognizedSchemaUri(String, Vec<String>),
+
     #[error("{t}: {0}", t = t!("dscerror.validation"))]
     Validation(String),
 

dsc_lib/src/dscresources/resource_manifest.rs

@@ -246,6 +246,16 @@ impl DscRepoSchema for ResourceManifest {
             ..Default::default()
         }
     }
+
+    fn validate_schema_uri(&self) -> Result<(), DscError> {
+        match Self::is_recognized_schema_uri(&self.schema_version) {
+            true => Ok(()),
+            false => Err(DscError::UnrecognizedSchemaUri(
+                self.schema_version.clone(),
+                Self::recognized_schema_uris(),
+            ))
+        }
+    }
 }
 
 /// Import a resource manifest from a JSON value.
@@ -288,3 +298,50 @@ pub fn validate_semver(version: &str) -> Result<(), semver::Error> {
     Version::parse(version)?;
     Ok(())
 }
+
+#[allow(unused_imports)]
+mod test {
+    use serde_json::json;
+
+    use crate::{dscerror::DscError, dscresources::resource_manifest::{import_manifest, ResourceManifest}, schemas::DscRepoSchema};
+
+    #[test]
+    fn test_validate_schema_uri_with_invalid_uri() {
+        let invalid_uri = "https://invalid.schema.uri".to_string();
+
+        let manifest = ResourceManifest{
+            schema_version: invalid_uri.clone(),
+            resource_type: "Microsoft.Dsc.Test/InvalidSchemaUri".to_string(),
+            version: "0.1.0".to_string(),
+            ..Default::default()
+        };
+
+        let ref result = manifest.validate_schema_uri();
+
+        assert!(result.as_ref().is_err());
+
+        match result.as_ref().unwrap_err() {
+            DscError::UnrecognizedSchemaUri(actual, recognized) => {
+                assert_eq!(actual, &invalid_uri);
+                assert_eq!(recognized, &ResourceManifest::recognized_schema_uris())
+            },
+            _ => {
+                panic!("Expected validate_schema_uri() to error on unrecognized schema uri, but was {:?}", result.as_ref().unwrap_err())
+            }
+        }
+    }
+
+    #[test]
+    fn test_validate_schema_uri_with_valid_uri() {
+        let manifest = ResourceManifest{
+            schema_version: ResourceManifest::default_schema_id_uri(),
+            resource_type: "Microsoft.Dsc.Test/ValidSchemaUri".to_string(),
+            version: "0.1.0".to_string(),
+            ..Default::default()
+        };
+
+        let result = manifest.validate_schema_uri();
+
+        assert!(result.is_ok());
+    }
+}

dsc_lib/src/schemas/mod.rs

@@ -2,6 +2,8 @@
 
 use schemars::{schema::{Metadata, Schema}, JsonSchema};
 
+use crate::dscerror::DscError;
+
 /// Defines the URI prefix for the hosted schemas.
 /// 
 /// While the schemas are currently hosted in the GitHub repository, DSC provides the shortened
@@ -447,6 +449,26 @@ pub trait DscRepoSchema : JsonSchema {
             Self::SCHEMA_SHOULD_BUNDLE
         )
     }
+
+    /// Indicates whether a given string is a recognized shema URI.
+    fn is_recognized_schema_uri(uri: &String) -> bool {
+        Self::recognized_schema_uris().contains(uri)
+    }
+
+    /// Validates the `$schema` keyword for deserializing instances.
+    /// 
+    /// This method simplifies the validation of a type that has the `$schema` keyword and expects
+    /// that instances of the type in data indicate which schema version DSC should use to validate
+    /// them.
+    /// 
+    /// This method includes a default implementation to avoid requiring the implementation for
+    /// types that don't define the `$schema` keyword in their serialized form.
+    /// 
+    /// Any DSC type that serializes with the `$schema` keyword **must** define this
+    /// method to actually validate the instance. 
+    fn validate_schema_uri(&self) -> Result<(), DscError> {
+        Ok(())
+    }
 }
 
 #[allow(unused_imports)]