Finish wiring up multiple return values using "BlockData" objects (#77)

PandaMagnus · Keboo · web-flow · commit 8081f29f1b7a · 2025-09-18T10:19:46.000-07:00
* Finish wiring up multiple return values using "BlockData" objects

* Update README with test data and BlockData details

Co-authored-by: Kevin B &lt;Keboo@users.noreply.github.com&gt;

* Finish requested changes to BlockData

---------

Co-authored-by: Kevin B &lt;Keboo@users.noreply.github.com&gt;
diff --git a/IntelliTect.TestTools.TestFramework.Tests/TestCaseTests/MultipleDependencyTests.cs b/IntelliTect.TestTools.TestFramework.Tests/TestCaseTests/MultipleDependencyTests.cs
@@ -1,10 +1,11 @@
-﻿using IntelliTect.TestTools.TestFramework.Tests.TestData.Dependencies;
-using IntelliTect.TestTools.TestFramework.Tests.TestData.TestBlocks;
+﻿using IntelliTect.TestTools.TestFramework.Tests.TestData.TestBlocks;
+using System;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace IntelliTect.TestTools.TestFramework.Tests.TestCaseTests
 {
-    public class MultipleDependencyTests
+    public class MultipleDependencyTests : TestBase
     {
         [Fact]
         public void ReturnDuplicateTypesDoesNotThrow()
@@ -38,5 +39,41 @@ public void FetchByObjectInstanceForMultipleDependencies()
             // Assert
             Assert.True(tc.Passed);
         }
+
+        [Fact]
+        public async Task ReturnMultipleObjectsStoresEachObjectSeparately()
+        {
+            // Arrange
+            TestCase tc = new TestBuilder()
+                .AddTestBlock<ExampleBlockWithMultipleReturns>(true)
+                .AddTestBlock<ExampleTestBlockWithExecuteArg>()
+                .AddTestBlock<ExampleTestBlockWithBoolReturn>()
+                .Build();
+
+            // Act
+            await tc.ExecuteAsync();
+
+            // Assert
+            Assert.True(tc.Passed);
+        }
+
+        [Fact]
+        public async Task ReturnMultipleObjectsExecutesSubsequentTestBlocks()
+        {
+            // Arrange
+
+            TestCase tc = new TestBuilder()
+                .AddTestBlock<ExampleBlockWithMultipleReturns>(false)
+                .AddTestBlock<ExampleTestBlockWithExecuteArg>()
+                .AddTestBlock<ExampleTestBlockWithBoolReturn>()
+                .Build();
+
+            // Act
+            var result = await Assert.ThrowsAsync<TestCaseException>(tc.ExecuteAsync);
+
+            // Assert
+            Assert.False(tc.Passed);
+            Assert.IsType<DivideByZeroException>(result.InnerException);
+        }
     }
 }
diff --git a/IntelliTect.TestTools.TestFramework.Tests/TestData/TestBlocks/MultipleDependencyBlocks.cs b/IntelliTect.TestTools.TestFramework.Tests/TestData/TestBlocks/MultipleDependencyBlocks.cs
@@ -21,4 +21,12 @@ public void Execute(string inputText, int inputNumber)
             Assert.Equal(1234, inputNumber);
         }
     }
+
+    public class ExampleBlockWithMultipleReturns : TestBlock
+    {
+        public BlockData<string, bool> Execute(bool returnValue)
+        {
+            return new BlockData<string, bool>("Testing", returnValue);
+        }
+    }
 }
diff --git a/IntelliTect.TestTools.TestFramework.Tests/TestDataTests.cs b/IntelliTect.TestTools.TestFramework.Tests/TestDataTests.cs
@@ -0,0 +1,71 @@
+﻿using System;
+using Xunit;
+
+namespace IntelliTect.TestTools.TestFramework.Tests;
+
+public class TestDataTests
+{
+    [Fact]
+    public void BlockDataT1T2ThrowsExceptionOnDuplicateTypes()
+    {
+        var exception = Assert.Throws<TypeInitializationException>(() => 
+        {
+            var _ = new BlockData<int, int>(1, 2);
+        });
+        Assert.IsType<InvalidOperationException>(exception.InnerException);
+        Assert.Equal("Duplicate type found: Int32 appears multiple times. BlockData must use different types to avoid unexpected behavior by the TestCase DI Container.",
+            exception.InnerException.Message);
+    }
+
+    [Fact]
+    public void BlockDataT1T2T3ThrowsExceptionOnDuplicateTypes()
+    {
+        var exception = Assert.Throws<TypeInitializationException>(() =>
+        {
+            var _ = new BlockData<int, bool, int>(1, true, 2);
+        });
+        var invalidOp = Assert.IsType<InvalidOperationException>(exception.InnerException);
+        Assert.Equal("Duplicate type found: Int32 appears multiple times. BlockData must use different types to avoid unexpected behavior by the TestCase DI Container.",
+            invalidOp.Message);
+    }
+
+    [Fact]
+    public void BlockDataT1T2T3T4ThrowsExceptionOnDuplicateTypes()
+    {
+        var exception = Assert.Throws<TypeInitializationException>(() =>
+        {
+            var _ = new BlockData<bool, double, int, int>(false, 0.5, 1, 2);
+        });
+        Assert.NotNull(exception.InnerException);
+        Assert.Equal(typeof(InvalidOperationException), exception.InnerException.GetType());
+        Assert.Equal("Duplicate type found: Int32 appears multiple times. BlockData must use different types to avoid unexpected behavior by the TestCase DI Container.",
+            exception.InnerException.Message);
+    }
+
+    [Fact]
+    public void BlockDataT1T2DoesNotThrowExceptionWithUniqueTypes()
+    {
+        BlockData<int, bool> blockData = new(1, true);
+        Assert.Equal(1, blockData.Data1);
+        Assert.True(blockData.Data2);
+    }
+
+    [Fact]
+    public void BlockDataT1T2T3DoesNotThrowExceptionWithUniqueTypes()
+    {
+        BlockData<ArgumentException, Exception, bool> blockData = new(new ArgumentException(), new Exception(), true);
+        Assert.IsType<ArgumentException>(blockData.Data1);
+        Assert.IsType<Exception>(blockData.Data2);
+        Assert.True(blockData.Data3);
+    }
+
+    [Fact]
+    public void BlockDataT1T2T3T4DoesNotThrowExceptionWithUniqueTypes()
+    {
+        BlockData<int, bool, string, double> blockData = new(1, true, "", 0.5);
+        Assert.Equal(1, blockData.Data1);
+        Assert.True(blockData.Data2);
+        Assert.Equal("", blockData.Data3);
+        Assert.Equal(0.5, blockData.Data4);
+    }
+}
diff --git a/IntelliTect.TestTools.TestFramework/BlockData.cs b/IntelliTect.TestTools.TestFramework/BlockData.cs
@@ -0,0 +1,82 @@
+﻿using System;
+using System.Collections.Generic;
+
+namespace IntelliTect.TestTools.TestFramework;
+
+public interface IBlockData
+{
+    public List<KeyValuePair<Type, object?>> Data { get; }
+}
+
+public class BlockData<T1, T2>(T1 data1, T2 data2) : IBlockData
+{
+    static BlockData()
+    {
+        ValidateData.ValidateUniqueTypes(typeof(T1), typeof(T2));
+    }
+
+    public T1 Data1 => data1;
+    public T2 Data2 => data2;
+    
+
+    List<KeyValuePair<Type, object?>> IBlockData.Data { get; } = 
+    [
+        new KeyValuePair<Type, object?>(typeof(T1), data1),
+        new KeyValuePair<Type, object?>(typeof(T2), data2)
+    ];
+}
+
+public class BlockData<T1, T2, T3>(T1 data1, T2 data2, T3 data3) : IBlockData
+{
+    static BlockData()
+    {
+        ValidateData.ValidateUniqueTypes(typeof(T1), typeof(T2), typeof(T3));
+    }
+
+    public T1 Data1 => data1;
+    public T2 Data2 => data2;
+    public T3 Data3 => data3;
+
+    List<KeyValuePair<Type, object?>> IBlockData.Data { get; } =
+    [
+        new KeyValuePair<Type, object?>(typeof(T1), data1),
+        new KeyValuePair<Type, object?>(typeof(T2), data2),
+        new KeyValuePair<Type, object?>(typeof(T3), data3)
+    ];
+}
+
+public class BlockData<T1, T2, T3, T4>(T1 data1, T2 data2, T3 data3, T4 data4) : IBlockData
+{
+    static BlockData()
+    {
+        ValidateData.ValidateUniqueTypes(typeof(T1), typeof(T2), typeof(T3), typeof(T4));
+    }
+
+    public T1 Data1 => data1;
+    public T2 Data2 => data2;
+    public T3 Data3 => data3;
+    public T4 Data4 => data4;
+
+    List<KeyValuePair<Type, object?>> IBlockData.Data { get; } =
+    [
+        new KeyValuePair<Type, object?>(typeof(T1), data1),
+        new KeyValuePair<Type, object?>(typeof(T2), data2),
+        new KeyValuePair<Type, object?>(typeof(T3), data3),
+        new KeyValuePair<Type, object?>(typeof(T4), data4)
+    ];
+}
+
+internal static class  ValidateData
+{
+    internal static void ValidateUniqueTypes(params Type[] types)
+    {
+        HashSet<Type> seenTypes = [];
+        foreach(Type type in types)
+        {
+            if (!seenTypes.Add(type))
+            {
+                throw new InvalidOperationException($"Duplicate type found: {type.Name} appears multiple times. BlockData must use different types to avoid unexpected behavior by the TestCase DI Container.");
+            }
+        }
+    }
+}
diff --git a/IntelliTect.TestTools.TestFramework/TestBuilder.cs b/IntelliTect.TestTools.TestFramework/TestBuilder.cs
@@ -354,7 +354,18 @@ private void GatherDependencies(
 
             if (executeReturns != typeof(void))
             {
-                outputs.Add(executeReturns);
+                if (executeReturns.GetInterfaces().Any(x => x == typeof(IBlockData)))
+                {
+                    Type[] blockData = executeReturns.GenericTypeArguments;
+                    foreach (Type bd in blockData)
+                    {
+                        outputs.Add(bd);
+                    }
+                }
+                else
+                {
+                    outputs.Add(executeReturns);
+                }
             }
         }
 
diff --git a/IntelliTect.TestTools.TestFramework/TestCase.cs b/IntelliTect.TestTools.TestFramework/TestCase.cs
@@ -142,15 +142,15 @@ public async Task ExecuteAsync()
             {
                 throw new TestCaseException("Test case failed.", TestBlockException);
             }
-            else if(TestBlockException is not null
+            else if (TestBlockException is not null
                 && ThrowOnFinallyBlockException
                 && FinallyBlockExceptions.Any())
             {
                 FinallyBlockExceptions.Insert(0, TestBlockException);
                 throw new AggregateException("Test case failed and finally blocks failed.",
                     FinallyBlockExceptions);
             }
-            else if(TestBlockException is null
+            else if (TestBlockException is null
                 && ThrowOnFinallyBlockException
                 && FinallyBlockExceptions.Any())
             {
@@ -199,7 +199,7 @@ private bool TryGetBlock(IServiceScope scope, Block block, out object blockInsta
                 _ = TryBuildBlock(scope, block, out foundBlock);
             }
 
-            if(foundBlock is not null)
+            if (foundBlock is not null)
             {
                 blockInstance = foundBlock;
                 result = true;
@@ -233,7 +233,7 @@ private bool TryBuildBlock(IServiceScope scope, Block block, out object? blockIn
                 object? obj = ActivateObject(scope, block, c.ParameterType, "constructor argument");
                 if (obj is null)
                 {
-                    if(!CheckForITestLogger(c.ParameterType))
+                    if (!CheckForITestLogger(c.ParameterType))
                     {
                         blockInstance = null;
                         return false;
@@ -267,7 +267,7 @@ private bool TrySetBlockProperties(IServiceScope scope, Block block, object bloc
                 object? obj = ActivateObject(scope, block, prop.PropertyType, "property");
                 if (obj is null)
                 {
-                    if(CheckForITestLogger(prop.PropertyType))
+                    if (CheckForITestLogger(prop.PropertyType))
                     {
                         continue;
                     }
@@ -288,12 +288,12 @@ private bool TryGetExecuteArguments(IServiceScope scope, Block block, out List<o
             foreach (ParameterInfo? ep in block.ExecuteParams)
             {
                 object? obj = null;
-                if(block.ExecuteArgumentOverrides.Count > 0)
+                if (block.ExecuteArgumentOverrides.Count > 0)
                 {
                     block.ExecuteArgumentOverrides.TryGetValue(ep.ParameterType, out obj);
                 }
 
-                if(obj is null)
+                if (obj is null)
                 {
                     obj = ActivateObject(scope, block, ep.ParameterType, "execute method argument");
                     if (obj is null)
@@ -325,9 +325,9 @@ private bool TryGetExecuteArguments(IServiceScope scope, Block block, out List<o
                     // Is the below check worth it?
                     // It is avoided if the test block asks for an interface if the dependency is implementing an interface.
                     // HOWEVER, this would facilitate injecting multiple different implementations in a test.
-                    if(obj is null)
+                    if (obj is null)
                     {
-                        foreach(var i in objectType.GetInterfaces())
+                        foreach (var i in objectType.GetInterfaces())
                         {
                             IEnumerable<object?> objs = scope.ServiceProvider.GetServices(i);
                             obj = objs.FirstOrDefault(o => o?.GetType() == objectType);
@@ -380,7 +380,7 @@ private async Task<bool> TryRunBlock(Block block, object blockInstance, List<obj
                 {
                     dynamic asyncOutput = block.ExecuteMethod.Invoke(blockInstance, executeArgs.ToArray());
                     await asyncOutput;
-                    if(block.AsyncReturnType != typeof(void))
+                    if (block.AsyncReturnType != typeof(void))
                     {
                         output = asyncOutput.GetAwaiter().GetResult();
                     }
@@ -389,12 +389,28 @@ private async Task<bool> TryRunBlock(Block block, object blockInstance, List<obj
                 {
                     output = block.ExecuteMethod.Invoke(blockInstance, executeArgs.ToArray());
                 }
-                
+
                 if (output is not null)
                 {
-                    Log?.TestBlockOutput(output);
-                    BlockOutput.Remove(output.GetType());
-                    BlockOutput.Add(output.GetType(), output);
+                    if (output is IBlockData blockData)
+                    {
+                        foreach (KeyValuePair<Type, object?> dataPoint in blockData.Data)
+                        {
+                            if (dataPoint.Value is not null)
+                            {
+                                Log?.TestBlockOutput(dataPoint.Value);
+                                BlockOutput.Remove(dataPoint.Key);
+                                BlockOutput.Add(dataPoint.Key, dataPoint.Value);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        Log?.TestBlockOutput(output);
+                        Type outputType = output.GetType();
+                        BlockOutput.Remove(outputType);
+                        BlockOutput.Add(outputType, output);
+                    }
                 }
                 result = true;
             }
diff --git a/README.md b/README.md
@@ -120,4 +120,15 @@ public async Task Test1()
 
 Also note that current behavior is that TestFramework will take the result of the awaited test block task and use that for future test block dependencies. If you have a test block that returns Task<bool>, TestFramework will capture the bool result to use.
 
+Test Data
+-----
+In normal situations, test blocks typically only return a single datapoint if any data is returned at all. The underlying container picks that object up and uses it for subsequent test blocks like demonstrated in the example project or unit tests. In some cases, it's not feasible to return just a single object, and so the BlockData object can handle returning 2 - 4 different data points. The execute method would look similar to this:
+```
+public BlockData<string, bool> Execute()
+{
+    return new BlockData<string, bool>("Testing", true);
+}
+```
+Note that in the out of the box BlockData objects, it will validate that the types are all unique; otherwise duplicate types would simply overwrite each other and cause unexpected behavior in subsquent block executions.
+
 More in depth examples are coming later!

Original file line number	Diff line number	Diff line change
`@@ -21,4 +21,12 @@ public void Execute(string inputText, int inputNumber)`
`21`	`21`	`Assert.Equal(1234, inputNumber);`
`22`	`22`	`}`
`23`	`23`	`}`
	`24`	`+`
	`25`	`+ public class ExampleBlockWithMultipleReturns : TestBlock`
	`26`	`+ {`
	`27`	`+ public BlockData<string, bool> Execute(bool returnValue)`
	`28`	`+ {`
	`29`	`+ return new BlockData<string, bool>("Testing", returnValue);`
	`30`	`+ }`
	`31`	`+ }`
`24`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -354,7 +354,18 @@ private void GatherDependencies(`
`354`	`354`
`355`	`355`	`if (executeReturns != typeof(void))`
`356`	`356`	`{`
`357`		`- outputs.Add(executeReturns);`
	`357`	`+ if (executeReturns.GetInterfaces().Any(x => x == typeof(IBlockData)))`
	`358`	`+ {`
	`359`	`+ Type[] blockData = executeReturns.GenericTypeArguments;`
	`360`	`+ foreach (Type bd in blockData)`
	`361`	`+ {`
	`362`	`+ outputs.Add(bd);`
	`363`	`+ }`
	`364`	`+ }`
	`365`	`+ else`
	`366`	`+ {`
	`367`	`+ outputs.Add(executeReturns);`
	`368`	`+ }`
`358`	`369`	`}`
`359`	`370`	`}`
`360`	`371`
Original file line number	Diff line number	Diff line change
`@@ -142,15 +142,15 @@ public async Task ExecuteAsync()`
`142`	`142`	`{`
`143`	`143`	`throw new TestCaseException("Test case failed.", TestBlockException);`
`144`	`144`	`}`
`145`		`- else if(TestBlockException is not null`
	`145`	`+ else if (TestBlockException is not null`
`146`	`146`	`&& ThrowOnFinallyBlockException`
`147`	`147`	`&& FinallyBlockExceptions.Any())`
`148`	`148`	`{`
`149`	`149`	`FinallyBlockExceptions.Insert(0, TestBlockException);`
`150`	`150`	`throw new AggregateException("Test case failed and finally blocks failed.",`
`151`	`151`	`FinallyBlockExceptions);`
`152`	`152`	`}`
`153`		`- else if(TestBlockException is null`
	`153`	`+ else if (TestBlockException is null`
`154`	`154`	`&& ThrowOnFinallyBlockException`
`155`	`155`	`&& FinallyBlockExceptions.Any())`
`156`	`156`	`{`
`@@ -199,7 +199,7 @@ private bool TryGetBlock(IServiceScope scope, Block block, out object blockInsta`
`199`	`199`	`_ = TryBuildBlock(scope, block, out foundBlock);`
`200`	`200`	`}`
`201`	`201`
`202`		`- if(foundBlock is not null)`
	`202`	`+ if (foundBlock is not null)`
`203`	`203`	`{`
`204`	`204`	`blockInstance = foundBlock;`
`205`	`205`	`result = true;`
`@@ -233,7 +233,7 @@ private bool TryBuildBlock(IServiceScope scope, Block block, out object? blockIn`
`233`	`233`	`object? obj = ActivateObject(scope, block, c.ParameterType, "constructor argument");`
`234`	`234`	`if (obj is null)`
`235`	`235`	`{`
`236`		`- if(!CheckForITestLogger(c.ParameterType))`
	`236`	`+ if (!CheckForITestLogger(c.ParameterType))`
`237`	`237`	`{`
`238`	`238`	`blockInstance = null;`
`239`	`239`	`return false;`
`@@ -267,7 +267,7 @@ private bool TrySetBlockProperties(IServiceScope scope, Block block, object bloc`
`267`	`267`	`object? obj = ActivateObject(scope, block, prop.PropertyType, "property");`
`268`	`268`	`if (obj is null)`
`269`	`269`	`{`
`270`		`- if(CheckForITestLogger(prop.PropertyType))`
	`270`	`+ if (CheckForITestLogger(prop.PropertyType))`
`271`	`271`	`{`
`272`	`272`	`continue;`
`273`	`273`	`}`
`@@ -288,12 +288,12 @@ private bool TryGetExecuteArguments(IServiceScope scope, Block block, out List<o`
`288`	`288`	`foreach (ParameterInfo? ep in block.ExecuteParams)`
`289`	`289`	`{`
`290`	`290`	`object? obj = null;`
`291`		`- if(block.ExecuteArgumentOverrides.Count > 0)`
	`291`	`+ if (block.ExecuteArgumentOverrides.Count > 0)`
`292`	`292`	`{`
`293`	`293`	`block.ExecuteArgumentOverrides.TryGetValue(ep.ParameterType, out obj);`
`294`	`294`	`}`
`295`	`295`
`296`		`- if(obj is null)`
	`296`	`+ if (obj is null)`
`297`	`297`	`{`
`298`	`298`	`obj = ActivateObject(scope, block, ep.ParameterType, "execute method argument");`
`299`	`299`	`if (obj is null)`
`@@ -325,9 +325,9 @@ private bool TryGetExecuteArguments(IServiceScope scope, Block block, out List<o`
`325`	`325`	`// Is the below check worth it?`
`326`	`326`	`// It is avoided if the test block asks for an interface if the dependency is implementing an interface.`
`327`	`327`	`// HOWEVER, this would facilitate injecting multiple different implementations in a test.`
`328`		`- if(obj is null)`
	`328`	`+ if (obj is null)`
`329`	`329`	`{`
`330`		`- foreach(var i in objectType.GetInterfaces())`
	`330`	`+ foreach (var i in objectType.GetInterfaces())`
`331`	`331`	`{`
`332`	`332`	`IEnumerable<object?> objs = scope.ServiceProvider.GetServices(i);`
`333`	`333`	`obj = objs.FirstOrDefault(o => o?.GetType() == objectType);`
`@@ -380,7 +380,7 @@ private async Task<bool> TryRunBlock(Block block, object blockInstance, List<obj`
`380`	`380`	`{`
`381`	`381`	`dynamic asyncOutput = block.ExecuteMethod.Invoke(blockInstance, executeArgs.ToArray());`
`382`	`382`	`await asyncOutput;`
`383`		`- if(block.AsyncReturnType != typeof(void))`
	`383`	`+ if (block.AsyncReturnType != typeof(void))`
`384`	`384`	`{`
`385`	`385`	`output = asyncOutput.GetAwaiter().GetResult();`
`386`	`386`	`}`
`@@ -389,12 +389,28 @@ private async Task<bool> TryRunBlock(Block block, object blockInstance, List<obj`
`389`	`389`	`{`
`390`	`390`	`output = block.ExecuteMethod.Invoke(blockInstance, executeArgs.ToArray());`
`391`	`391`	`}`
`392`		`-`
	`392`	`+`
`393`	`393`	`if (output is not null)`
`394`	`394`	`{`
`395`		`- Log?.TestBlockOutput(output);`
`396`		`- BlockOutput.Remove(output.GetType());`
`397`		`- BlockOutput.Add(output.GetType(), output);`
	`395`	`+ if (output is IBlockData blockData)`
	`396`	`+ {`
	`397`	`+ foreach (KeyValuePair<Type, object?> dataPoint in blockData.Data)`
	`398`	`+ {`
	`399`	`+ if (dataPoint.Value is not null)`
	`400`	`+ {`
	`401`	`+ Log?.TestBlockOutput(dataPoint.Value);`
	`402`	`+ BlockOutput.Remove(dataPoint.Key);`
	`403`	`+ BlockOutput.Add(dataPoint.Key, dataPoint.Value);`
	`404`	`+ }`
	`405`	`+ }`
	`406`	`+ }`
	`407`	`+ else`
	`408`	`+ {`
	`409`	`+ Log?.TestBlockOutput(output);`
	`410`	`+ Type outputType = output.GetType();`
	`411`	`+ BlockOutput.Remove(outputType);`
	`412`	`+ BlockOutput.Add(outputType, output);`
	`413`	`+ }`
`398`	`414`	`}`
`399`	`415`	`result = true;`
`400`	`416`	`}`