Add Tests

Author: adithyaselv

src/libraries/Microsoft.PowerFx.Core/Functions/UserDefinedFunction.cs

@@ -191,9 +191,14 @@ public void CheckTypesOnDeclaration(CheckTypesContext context, DType actualBodyR
             Contracts.AssertValue(actualBodyReturnType);
             Contracts.AssertValue(binding);
 
-            if (!ReturnType.Accepts(actualBodyReturnType, exact: true, useLegacyDateTimeAccepts: false, usePowerFxV1CompatibilityRules: context.Features.PowerFxV1CompatibilityRules, true))
+            if (!ReturnType.Accepts(
+                actualBodyReturnType, 
+                exact: true, 
+                useLegacyDateTimeAccepts: false,
+                usePowerFxV1CompatibilityRules: context.Features.PowerFxV1CompatibilityRules,
+                restrictiveAggregateTypes: true))
             {
-                if (actualBodyReturnType.CoercesTo(ReturnType, true, false, context.Features, true))
+                if (actualBodyReturnType.CoercesTo(ReturnType, true, false, context.Features, restrictiveAggregateTypes: true))
                 {
                     _binding.SetCoercedType(binding.Top, ReturnType);
                 }

src/libraries/Microsoft.PowerFx.Core/Types/DType.cs

@@ -1851,7 +1851,7 @@ private bool AcceptsEntityType(DType type, bool usePowerFxV1CompatibilityRules)
         /// <param name="useLegacyDateTimeAccepts">Legacy rules for accepting date/time types.</param>
         /// <param name="usePowerFxV1CompatibilityRules">Use PFx v1 compatibility rules if enabled (less
         /// permissive Accepts relationships).</param>
-        /// <param name="restrictiveAggregateTypes">restrictiveAggregateTypes.</param>
+        /// <param name="restrictiveAggregateTypes">Flag to restrict using aggregate types with more fields than expected.</param>
         /// <returns>
         /// True if <see cref="DType"/> accepts <paramref name="type"/>, false otherwise.
         /// </returns>
@@ -1886,6 +1886,7 @@ public bool Accepts(DType type, bool exact, bool useLegacyDateTimeAccepts, bool
         /// <param name="useLegacyDateTimeAccepts">Legacy rules for accepting date/time types.</param>
         /// <param name="usePowerFxV1CompatibilityRules">Use PFx v1 compatibility rules if enabled (less
         /// permissive Accepts relationships).</param>
+        /// <param name="restrictiveAggregateTypes">Flag to restrict using aggregate types with more fields than expected.</param>
         /// <returns>
         /// True if <see cref="DType"/> accepts <paramref name="type"/>, false otherwise.
         /// </returns>
@@ -3208,7 +3209,8 @@ public bool AggregateCoercesTo(DType typeDest, out bool isSafe, out DType coerci
                     out schemaDifferenceType,
                     aggregateCoercion: true,
                     isTopLevelCoercion: false,
-                    features);
+                    features,
+                    restrictiveAggregateTypes);
             }
 
             if (Kind != typeDest.Kind)
@@ -3243,7 +3245,8 @@ public bool AggregateCoercesTo(DType typeDest, out bool isSafe, out DType coerci
                         out var fieldSchemaDifferenceType,
                         aggregateCoercion,
                         isTopLevelCoercion: false,
-                        features);
+                        features,
+                        restrictiveAggregateTypes);
 
                     // This is the attempted coercion type.  If we fail, we need to know this for error handling
                     coercionType = coercionType.Add(typedName.Name, fieldCoercionType);

src/tests/Microsoft.PowerFx.Core.Tests.Shared/UserDefinedTypeTests.cs

@@ -156,6 +156,20 @@ public void TestRecordOfErrors(string typeDefinition, string expectedMessageKey)
             Assert.Contains(errors, e => e.MessageKey.Contains(expectedMessageKey));
         }
 
+        [Theory]
+        [InlineData("f():T = {x: 5, y: 5}; T := Type({x: Number});", "ErrUDF_ReturnTypeSchemaDoesNotMatch")]
+        [InlineData("f(x:T):Number = x.n; T := Type({n: Number}); g(): Number = f({n: 5, m: 5});", "ErrBadSchema_ExpectedType")]
+        [InlineData("f():T = [{x: 5, y: 5}]; T := Type([{x: Number}]);", "ErrUDF_ReturnTypeSchemaDoesNotMatch")]
+        [InlineData("f(x:T):T = x; T := Type([{n: Number}]); g(): T = f([{n: 5, m: 5}]);", "ErrBadSchema_ExpectedType")]
+        public void TestAggregateTypeErrors(string typeDefinition, string expectedMessageKey)
+        {
+            var checkResult = new DefinitionsCheckResult()
+                                            .SetText(typeDefinition)
+                                            .SetBindingInfo(_primitiveTypes);
+            var errors = checkResult.ApplyErrors();
+            Assert.Contains(errors, e => e.MessageKey.Contains(expectedMessageKey));
+        }
+
         [Theory]
         [InlineData("T := Type({ x: 5+5, y: -5 });", 2)]
         [InlineData("T := Type(Type(Number));", 1)]

src/tests/Microsoft.PowerFx.Interpreter.Tests.Shared/RecalcEngineTests.cs

@@ -1871,13 +1871,6 @@ protected override bool TryGetField(FormulaType fieldType, string fieldName, out
             "getAge({Name: \"Bob\", Age: 21})",
             true,
             21.0)]
-        [InlineData(
-            @"Employee := Type({Name: Text, Age: Number, Title: Text}); Employees := Type([Employee]);  EmployeeNames := Type([{Name: Text}]); 
-              getNames(e: Employees):EmployeeNames = ShowColumns(e, Name); 
-              getNamesCount(e: EmployeeNames):Number = CountRows(getNames(e));",
-            "getNamesCount([{Name: \"Jim\", Age:25}, {Name: \"Tony\", Age:42}])",
-            true,
-            2.0)]
         [InlineData(
             @"Employee := Type({Name: Text, Age: Number, Title: Text}); 
               getAge(e: Employee): Number = e.Age;
@@ -1946,14 +1939,55 @@ protected override bool TryGetField(FormulaType fieldType, string fieldName, out
             true,
             1.0)]
 
-        // Aggregate types with more than expected fields are not allowed in UDF
+        // Aggregate types with more than expected fields are not allowed in UDF args and return types
+        // Records
         [InlineData(
             "f():T = {x: 5, y: 5}; T := Type({x: Number});",
-            "f().x",
+            "",
+            false)]
+        [InlineData(
+            "f():T = {x: 5, y: 5}; T1 := Type([{x: Number}]); T2 := Type(RecordOf(T1));",
+            "",
+            false)]
+        [InlineData(
+            "g(x:T):Number = x.n; T := Type({n: Number});",
+            "g({x: 5, y: 5})",
+            false)]
+
+        // Nested Records
+        [InlineData(
+            "f():T = {a: 5, b: {c: {d: 5, e:42}}}; T := Type({a: Number, b: {c: {d: Number}}});",
+            "",
+            false)]
+        [InlineData(
+            "g(x:T):Number = x.b.c.d; T := Type({a: Number, b: {c: {d: Number}}});",
+            "g({a: 5, b: {c: {d: 5, e:42}}})",
+            false)]
+
+        // Tables
+        [InlineData(
+            "f():T = [{x: 5, y: 5}]; T := Type([{x: Number}]);",
+            "",
             false)]
         [InlineData(
             "People := Type([{Name: Text, Age: Number}]); countMinors(p: People): Number = CountRows(Filter(p, Age < 18));",
             "countMinors([{Name: \"Bob\", Age: 21, Title: \"Engineer\"}, {Name: \"Alice\", Age: 25, Title: \"Manager\"}])",
+            false)]
+        [InlineData(
+            @"Employee := Type({Name: Text, Age: Number, Title: Text}); Employees := Type([Employee]);  EmployeeNames := Type([{Name: Text}]); 
+              getNames(e: Employees):EmployeeNames = ShowColumns(e, Name); 
+              getNamesCount(e: EmployeeNames):Number = CountRows(getNames(e));",
+            "getNamesCount([{Name: \"Jim\", Age:25}, {Name: \"Tony\", Age:42}])",
+            false)]
+
+        // Nested Tables
+        [InlineData(
+            "f():T = {a: 5, b: [{c: {d: 5, e:42}}]}; T := Type([{a: Number, b: [{c: {d: Number}}]}]);",
+            "",
+            false)]
+        [InlineData(
+            "g(x:T):Number = First(First(x).b).c.d; T := Type([{a: Number, b: [{c: {d: Number}}]}])",
+            "g({a: 5, b: [{c: {d: 5, e:42}}]})",
             false)]
         public void UserDefinedTypeTest(string userDefinitions, string evalExpression, bool isValid, double expectedResult = 0)
         {