fix#375 - Addedunit tests for discriminator/required fields schema rules

Author: senthilkumarmohan

src/Microsoft.OpenApi/Properties/SRResource.Designer.cs

@@ -220,7 +220,7 @@
     <value>Schema {0} must contain property specified in the discriminator {1}.</value>
   </data>
   <data name="Validation_SchemaMustContainPropertySpecifiedInTheRequiredField" xml:space="preserve">
-    <value>Schema {0} must contain property specified in the required field {0}.</value>
+    <value>Schema {0} must contain property specified in the required field {1}.</value>
   </data>
   <data name="Validation_SchemaRequiredFieldListMustContainThePropertySpecifiedInTheDiscriminator" xml:space="preserve">
     <value>Schema {0} must contain property specified in the discriminator {1} in the required field list.</value>

src/Microsoft.OpenApi/Properties/SRResource.resx

@@ -73,9 +73,9 @@ public static class OpenApiSchemaRules
                         {
                             if (!schema.Properties.ContainsKey(requiredField))
                             {
-                                context.CreateError(nameof(ValidateSchemaDiscriminator),
+                                context.CreateError(nameof(ValidateSchemaRequiredFields),
                                                     string.Format(SRResource.Validation_SchemaMustContainPropertySpecifiedInTheRequiredField,
-                                                                                    requiredField));
+                                                                                    schema.Reference.Id, requiredField));
                             }
                         }
                     }

src/Microsoft.OpenApi/Validations/Rules/OpenApiSchemaRules.cs

@@ -352,5 +352,80 @@ public void ValidateAnyOfCompositeSchemaMustContainPropertySpecifiedInTheDiscrim
 
                 });
         }
+
+        [Fact]
+        public void ValidateSchemaMustContainPropertySpecifiedInTheRequiredFieldList()
+        {
+            IEnumerable<OpenApiError> errors;
+            var components = new OpenApiComponents
+            {
+                Schemas = {
+                    {
+                        "schema1",
+                        new OpenApiSchema
+                        {
+                            Type = "object",
+                            Required = { "property1" },
+                            Reference = new OpenApiReference { Id = "schema1" }
+                        }
+                    }
+                }
+            };
+            // Act
+            var validator = new OpenApiValidator(ValidationRuleSet.GetDefaultRuleSet());
+            var walker = new OpenApiWalker(validator);
+            walker.Walk(components);
+
+            errors = validator.Errors;
+            bool result = !errors.Any();
+
+            // Assert
+            result.Should().BeFalse();
+            errors.ShouldAllBeEquivalentTo(new List<OpenApiValidatorError>
+            {
+                    new OpenApiValidatorError(nameof(OpenApiSchemaRules.ValidateSchemaRequiredFields),"#/schemas/schema1/required",
+                        string.Format(SRResource.Validation_SchemaMustContainPropertySpecifiedInTheRequiredField,
+                                    "schema1", "property1")),
+            });
+        }
+
+        [Fact]
+        public void ValidateSchemaMustContainPropertySpecifiedInTheDiscriminator()
+        {
+            IEnumerable<OpenApiError> errors;
+            var components = new OpenApiComponents
+            {
+                Schemas = {
+                    {
+                        "schema1",
+                        new OpenApiSchema
+                        {
+                            Type = "object",
+                            Discriminator = new OpenApiDiscriminator { PropertyName = "property1" },
+                            Reference = new OpenApiReference { Id = "schema1" }
+                        }
+                    }
+                }
+            };
+            // Act
+            var validator = new OpenApiValidator(ValidationRuleSet.GetDefaultRuleSet());
+            var walker = new OpenApiWalker(validator);
+            walker.Walk(components);
+
+            errors = validator.Errors;
+            bool result = !errors.Any();
+
+            // Assert
+            result.Should().BeFalse();
+            errors.ShouldAllBeEquivalentTo(new List<OpenApiValidatorError>
+            {
+                    new OpenApiValidatorError(nameof(OpenApiSchemaRules.ValidateSchemaDiscriminator),"#/schemas/schema1/discriminator",
+                        string.Format(SRResource.Validation_SchemaMustContainPropertySpecifiedInTheDiscriminator,
+                                    "schema1", "property1")),
+                    new OpenApiValidatorError(nameof(OpenApiSchemaRules.ValidateSchemaDiscriminator),"#/schemas/schema1/discriminator",
+                        string.Format(SRResource.Validation_SchemaRequiredFieldListMustContainThePropertySpecifiedInTheDiscriminator,
+                                    "schema1", "property1"))
+            });
+        }
     }
 }