fix: improve array validation in integration test assertions

- Add support for string[], int[], bool[] typed arrays in test assertions
- Extract array validation logic into ValidateArrayAttribute helper method
- Handle JArray deserialization from JSON properly
- Improve error messages with type information
- Add regular attributes to empty array test endpoints to ensure transaction capture

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: tippmar-nr

tests/Agent/IntegrationTests/Applications/AspNetCoreWebApiCustomAttributesApplication/Controllers/AttributeTestingController.cs

@@ -73,6 +73,10 @@ public string CustomArrayAttributes()
     [Route("api/CustomEmptyArrayAttributes")]
     public string CustomEmptyArrayAttributes()
     {
+        // Add a regular attribute to ensure transaction gets traced
+        NewRelic.Api.Agent.NewRelic.GetAgent().CurrentTransaction.AddCustomAttribute("test", "empty-arrays");
+
+        // These should be skipped by our array logic
         NewRelic.Api.Agent.NewRelic.GetAgent().CurrentTransaction.AddCustomAttribute("emptyArray", new string[] { });
         NewRelic.Api.Agent.NewRelic.GetAgent().CurrentTransaction.AddCustomAttribute("nullOnlyArray", new object[] { null, null });
 

tests/Agent/IntegrationTests/Applications/CustomAttributesWebApi/MyController.cs

@@ -80,6 +80,10 @@ public string CustomArrayAttributes()
     [Route("api/CustomEmptyArrayAttributes")]
     public string CustomEmptyArrayAttributes()
     {
+        // Add a regular attribute to ensure transaction gets traced
+        NewRelic.Api.Agent.NewRelic.GetAgent().CurrentTransaction.AddCustomAttribute("test", "empty-arrays");
+
+        // These should be skipped by our array logic
         NewRelic.Api.Agent.NewRelic.GetAgent().CurrentTransaction.AddCustomAttribute("emptyArray", new string[] { });
         NewRelic.Api.Agent.NewRelic.GetAgent().CurrentTransaction.AddCustomAttribute("nullOnlyArray", new object[] { null, null });
 

tests/Agent/IntegrationTests/IntegrationTestHelpers/Assertions.cs

@@ -1083,42 +1083,98 @@ private static bool ValidateAttributeValues(KeyValuePair<string, object> expecte
 
                 break;
             }
+            case string[] expectedStringArray:
+            {
+                ValidateArrayAttribute(expectedAttribute, rawActualValue, expectedStringArray.Cast<object>().ToArray(), builder, wireModelTypeName, ref succeeded);
+                break;
+            }
+            case int[] expectedIntArray:
+            {
+                ValidateArrayAttribute(expectedAttribute, rawActualValue, expectedIntArray.Cast<object>().ToArray(), builder, wireModelTypeName, ref succeeded);
+                break;
+            }
+            case bool[] expectedBoolArray:
+            {
+                ValidateArrayAttribute(expectedAttribute, rawActualValue, expectedBoolArray.Cast<object>().ToArray(), builder, wireModelTypeName, ref succeeded);
+                break;
+            }
             case object[] expectedArray:
             {
-                var actualValue = rawActualValue as object[];
-                if (actualValue == null)
+                ValidateArrayAttribute(expectedAttribute, rawActualValue, expectedArray, builder, wireModelTypeName, ref succeeded);
+                break;
+            }
+            default:
+                throw new NotImplementedException("Attribute handling for your type has not yet been implemented. The method only supports strings and bools. Update to add your type!");
+        }
+
+        return succeeded;
+    }
+
+    private static void ValidateArrayAttribute(KeyValuePair<string, object> expectedAttribute, object rawActualValue, object[] expectedArray, StringBuilder builder, string wireModelTypeName, ref bool succeeded)
+    {
+        // Handle different possible types of arrays from JSON deserialization
+        object[] actualArray = null;
+
+        if (rawActualValue is object[] directArray)
+        {
+            actualArray = directArray;
+        }
+        else if (rawActualValue is Newtonsoft.Json.Linq.JArray jArray)
+        {
+            actualArray = jArray.ToObject<object[]>();
+        }
+        else if (rawActualValue is System.Collections.IEnumerable enumerable)
+        {
+            actualArray = enumerable.Cast<object>().ToArray();
+        }
+
+        if (actualArray == null)
+        {
+            builder.AppendFormat("Attribute named {0} in the {3} had an unexpected type.  Expected: array [{1}], Actual type: {2}",
+                expectedAttribute.Key, string.Join(", ", expectedArray), rawActualValue?.GetType()?.Name ?? "null", wireModelTypeName);
+            builder.AppendLine();
+            succeeded = false;
+        }
+        else if (actualArray.Length != expectedArray.Length)
+        {
+            builder.AppendFormat("Attribute named {0} in the {3} had an unexpected array length.  Expected: {1}, Actual: {2}",
+                expectedAttribute.Key, expectedArray.Length, actualArray.Length, wireModelTypeName);
+            builder.AppendLine();
+            succeeded = false;
+        }
+        else
+        {
+            // Compare array elements
+            for (int i = 0; i < expectedArray.Length; i++)
+            {
+                var expectedElement = expectedArray[i];
+                var actualElement = actualArray[i];
+
+                // Handle different JSON number types (long vs int)
+                bool elementsEqual = false;
+                if (expectedElement is int expectedInt && actualElement is long actualLong)
                 {
-                    builder.AppendFormat("Attribute named {0} in the {3} had an unexpected value.  Expected: array [{1}], Actual: {2}", expectedAttribute.Key, string.Join(", ", expectedArray), rawActualValue, wireModelTypeName);
-                    builder.AppendLine();
-                    succeeded = false;
+                    elementsEqual = expectedInt == actualLong;
                 }
-                else if (actualValue.Length != expectedArray.Length)
+                else if (expectedElement is long expectedLong && actualElement is int actualInt)
                 {
-                    builder.AppendFormat("Attribute named {0} in the {3} had an unexpected array length.  Expected: {1}, Actual: {2}", expectedAttribute.Key, expectedArray.Length, actualValue.Length, wireModelTypeName);
-                    builder.AppendLine();
-                    succeeded = false;
+                    elementsEqual = expectedLong == actualInt;
                 }
                 else
                 {
-                    // Compare array elements
-                    for (int i = 0; i < expectedArray.Length; i++)
-                    {
-                        if (!Equals(expectedArray[i], actualValue[i]))
-                        {
-                            builder.AppendFormat("Attribute named {0} in the {3} had an unexpected value at index {4}.  Expected: {1}, Actual: {2}", expectedAttribute.Key, expectedArray[i], actualValue[i], wireModelTypeName, i);
-                            builder.AppendLine();
-                            succeeded = false;
-                        }
-                    }
+                    elementsEqual = Equals(expectedElement, actualElement);
                 }
 
-                break;
+                if (!elementsEqual)
+                {
+                    builder.AppendFormat("Attribute named {0} in the {3} had an unexpected value at index {4}.  Expected: {1} ({5}), Actual: {2} ({6})",
+                        expectedAttribute.Key, expectedElement, actualElement, wireModelTypeName, i,
+                        expectedElement?.GetType()?.Name ?? "null", actualElement?.GetType()?.Name ?? "null");
+                    builder.AppendLine();
+                    succeeded = false;
+                }
             }
-            default:
-                throw new NotImplementedException("Attribute handling for your type has not yet been implemented. The method only supports strings and bools. Update to add your type!");
         }
-
-        return succeeded;
     }
 
     private static bool IsNullOrEqual(string expectedValue, string actualValue)