Adding tests (#25)

* add compiled rust tests
split buildTask test to theory
invalid json error test

* trigger tests on all commits

.github/workflows/dotnet.yml

@@ -5,9 +5,7 @@ name: compile and test
 
 on:
   push:
-    branches: [ "main" ]
   pull_request:
-    branches: [ "main" ]
 
 jobs:
   test:

.gitignore

@@ -4,4 +4,5 @@ obj/
 Playground/
 /MSBuildWasmLocal.sln
 /examples/go
-templates/src
+templates/src
+/test/WasmTasksTests/GeneratedRustTests

src/WasmTask.cs

@@ -301,11 +301,11 @@ private void ReflectOutputJsonToClassProperties(string taskOutputJson)
             }
             catch (JsonException ex)
             {
-                Log.LogError($"Error parsing JSON: {ex.Message}");
+                Log.LogError($"Error parsing output JSON: {ex.Message}");
             }
             catch (Exception ex)
             {
-                Log.LogError($"Error Reflecting properties from Json to Class: {ex.Message}");
+                Log.LogError($"Error Reflecting properties from Json to Class after task run: {ex.Message}");
             }
         }
 

src/WasmTaskFactory.cs

@@ -15,10 +15,12 @@ namespace MSBuildWasm
     /// </summary>
     public class WasmTaskFactory : ITaskFactory2
     {
-        // TODO avoid hardcoded when possible
+        /// <summary>
+        /// Name displayed in the MSBuild log.
+        /// </summary>
         public string FactoryName => nameof(WasmTaskFactory);
+        public TaskLoggingHelper Log { get; set; }
         private TaskPropertyInfo[] _taskProperties;
-        private TaskLoggingHelper _log;
         private bool _taskInfoReceived = false;
         private string _taskName;
         private string _taskPath;
@@ -45,7 +47,7 @@ public TaskPropertyInfo[] GetTaskParameters()
 
         public bool Initialize(string taskName, IDictionary<string, string> factoryIdentityParameters, IDictionary<string, TaskPropertyInfo> parameterGroup, string taskBody, IBuildEngine taskFactoryLoggingHost)
         {
-            _log = new TaskLoggingHelper(taskFactoryLoggingHost, taskName)
+            Log = new TaskLoggingHelper(taskFactoryLoggingHost, taskName)
             {
                 HelpKeywordPrefix = $"WasmTask.{taskName}."
             };
@@ -74,7 +76,7 @@ private void GetCustomWasmTaskProperties()
             {
                 using var engine = new Engine();
                 using var module = Wasmtime.Module.FromFile(engine, _taskPath);
-                using var linker = new WasmTaskLinker(engine, _log);
+                using var linker = new WasmTaskLinker(engine, Log);
                 using var store = new Store(engine);
                 linker.DefineWasi();
                 linker.LinkLogFunctions(store);
@@ -84,35 +86,39 @@ private void GetCustomWasmTaskProperties()
                 Action getTaskInfo = instance.GetAction(WasmTask.GetTaskInfoFunctionName);
                 if (getTaskInfo == null)
                 {
-                    _log.LogError("Function 'GetTaskInfo' not found in the WebAssembly module.");
+                    Log.LogError("Function 'GetTaskInfo' not found in the WebAssembly module.");
                     return;
                 }
 
                 getTaskInfo.Invoke();
             }
             catch (WasmtimeException ex)
             {
-                _log.LogErrorFromException(ex, true);
+                Log.LogErrorFromException(ex, true);
             }
             if (!_taskInfoReceived)
             {
-                _log.LogError("Task info was not received from the WebAssembly module.");
+                Log.LogError("Task info was not received from the WebAssembly module.");
             }
         }
 
         /// <summary>
         /// Handling callback with Task Info JSON.
         /// </summary>
         /// <remarks>WASIp2: get structured info from GetTaskInfo function output and parse it via classes from wit-bindgen and convert them to properties, this event scheme unnecessary</remarks>
-        private void OnTaskInfoReceived(object sender, string taskInfoJson)
+        internal void OnTaskInfoReceived(object sender, string taskInfoJson)
         {
             try
             {
                 _taskProperties = Serializer.DeserializeTaskInfoJson(taskInfoJson);
             }
-            catch (Exception ex) when (ex is JsonException || ex is KeyNotFoundException || ex is ArgumentException)
+            catch (Exception ex) when (ex is JsonException || ex is KeyNotFoundException || ex is ArgumentException || ex is InvalidOperationException)
+            {
+                Log.LogError("Could not deserialize Task Info JSON. {0}:{1}", ex.GetType().ToString(), ex.Message);
+            }
+            catch (Exception ex)
             {
-                _log.LogErrorFromException(ex);
+                Log.LogError("Unknown error in Task Info JSON deserialization. {0}", ex.Message);
             }
             _taskInfoReceived = true;
         }

test/WasmTasksTests/WasmTaskFactory_Tests.cs

@@ -50,29 +50,47 @@ public void BuildTaskType_CreatesTypeWithCorrectProperties(Type propType)
             Assert.NotNull(resultType.GetProperty(prop1name));
             Assert.Null(resultType.GetProperty(prop2name));
         }
-        // split/theory
-        [Fact]
-        public void BuildTaskType_CreatesTypeWithCorrectAttributes()
+
+        [Theory]
+        [InlineData("StringProp", typeof(string), true, false)]
+        [InlineData("BoolProp", typeof(bool), false, true)]
+        [InlineData("TaskItemProp", typeof(ITaskItem), false, false)]
+        [InlineData("StringArrayProp", typeof(string[]), true, true)]
+        public void BuildTaskType_CreatesTypeWithCorrectAttributes(string propertyName, Type propertyType, bool isOutput, bool isRequired)
         {
             // Arrange
             const string taskName = "TestTask";
-            const string prop1name = "p1";
-            const string prop2name = "p2";
             TaskPropertyInfo[] properties = new[]
             {
-                new TaskPropertyInfo(prop1name, typeof(string), output: true, required: false),
-                new TaskPropertyInfo(prop2name, typeof(bool), false, true)
-            };
+            new TaskPropertyInfo(propertyName, propertyType, isOutput, isRequired)
+        };
 
             // Act
             Type resultType = WasmTaskReflectionBuilder.BuildTaskType(taskName, properties);
 
             // Assert
-            Assert.NotNull(resultType.GetProperty(prop1name)!.GetCustomAttribute<OutputAttribute>());
-            Assert.Null(resultType.GetProperty(prop1name)!.GetCustomAttribute<RequiredAttribute>());
-            Assert.NotNull(resultType.GetProperty(prop2name)!.GetCustomAttribute<RequiredAttribute>());
-            Assert.Null(resultType.GetProperty(prop2name)!.GetCustomAttribute<OutputAttribute>());
+            PropertyInfo? property = resultType.GetProperty(propertyName);
+            Assert.NotNull(property);
+
+            if (isOutput)
+            {
+                Assert.NotNull(property!.GetCustomAttribute<OutputAttribute>());
+            }
+            else
+            {
+                Assert.Null(property!.GetCustomAttribute<OutputAttribute>());
+            }
+
+            if (isRequired)
+            {
+                Assert.NotNull(property!.GetCustomAttribute<RequiredAttribute>());
+            }
+            else
+            {
+                Assert.Null(property!.GetCustomAttribute<RequiredAttribute>());
+            }
         }
+
         [Fact]
         public void ConvertJsonTaskInfoToProperties_ShouldParseProperties()
         {
@@ -90,16 +108,21 @@ public void ConvertJsonTaskInfoToProperties_ShouldParseProperties()
             propsExpected.ShouldBeEquivalentTo(propsParsed);
         }
 
-        // the task returns undeserializable json, should error
-        //[Fact]
-        //public void GetTaskInfo_InvalidJson_ShouldError()
-        //{
-        //    const string invalidJson = "{ \"Properties\": { \"Dirs\": { \"type\": \"ITaskItem[]\", \"required\": true, \"output\": false }, \"MergedDir\": { \"type\": \"ITaskItem\", \"required\": false, \"output\": true }, \"MergedName\": { \"type\": \"string\", \"required\": false, \"output\": false } ";
+        [Fact]
+        public void GetTaskInfo_InvalidJson_ShouldError()
+        {
+            const string invalidJson = "{ \"Properties\": { \"Dirs\": { \"type\": \"ITaskItem[]\", \"required\": true, \"output\": false }, \"MergedDir\": { \"type\": \"ITaskItem\", \"required\": false, \"output\": true }, \"MergedName\": { \"type\": \"string\", \"required\": false, \"output\": false {} ";
 
-        //    WasmTaskFactory factory = new WasmTaskFactory();
+            MockEngine m = new MockEngine();
 
-        //    factory.OnTaskInfoReceived(null, invalidJson);
+            WasmTaskFactory factory = new WasmTaskFactory
+            {
+                Log = new Microsoft.Build.Utilities.TaskLoggingHelper(m, "TestTask")
+            };
 
+            factory.OnTaskInfoReceived(null, invalidJson);
+            m.AssertLogContains("Error");
+        }